# Google Images Scraper (`crawlerbros/google-images-scraper`) Actor

Extract image data from Google Images search. Scrape image URLs, dimensions, thumbnails, page titles, origins, and content URLs for any search query.

- **URL**: https://apify.com/crawlerbros/google-images-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, SEO tools, Other
- **Stats:** 66 total users, 7 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Images Scraper

Scrape image data from Google Images search results at scale. Extract full-resolution image URLs, dimensions, thumbnails, page titles, source domains, and content page URLs for any search query.

Perfect for building image datasets, monitoring brand visuals, competitor research, content curation, and training data collection.

### What data can you extract from Google Images?

For every image result, the scraper returns:

| Field             | Type      | Description                                          |
| ----------------- | --------- | ---------------------------------------------------- |
| `query`           | `string`  | The search query used                                |
| `imageUrl`        | `string`  | Direct URL to the full-resolution image              |
| `imageWidth`      | `integer` | Width of the full-resolution image in pixels         |
| `imageHeight`     | `integer` | Height of the full-resolution image in pixels        |
| `thumbnailUrl`    | `string`  | URL of the Google-cached thumbnail                   |
| `thumbnailWidth`  | `integer` | Width of the thumbnail in pixels                     |
| `thumbnailHeight` | `integer` | Height of the thumbnail in pixels                    |
| `title`           | `string`  | Page title of the website containing the image       |
| `origin`          | `string`  | Domain of the website where the image is hosted      |
| `contentUrl`      | `string`  | URL of the web page containing the image             |

### How to use Google Images Scraper

1. **Add your search queries** - Enter one or more image search terms (e.g., "sunset landscape", "product packaging design")
2. **Set the result limit** - Choose how many images to extract per query (1 to 500)
3. **Run the scraper** - Click Start and the scraper will collect all image data automatically
4. **Export your data** - Download results as JSON, CSV, Excel, or connect via API

### Input

| Field                | Type       | Description                                          | Default    |
| -------------------- | ---------- | ---------------------------------------------------- | ---------- |
| `queries`            | `string[]` | List of image search queries                         | _required_ |
| `maxResultsPerQuery` | `integer`  | Maximum number of image results to extract per query | `100`      |

#### Example Input

```json
{
  "queries": ["sunset landscape", "modern architecture"],
  "maxResultsPerQuery": 100
}
````

### Output

#### Example Output

```json
[
  {
    "query": "sunset landscape",
    "imageUrl": "https://images.pexels.com/photos/694636/pexels-photo-694636.jpeg",
    "imageWidth": 750,
    "imageHeight": 1123,
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQXLRmm...",
    "thumbnailWidth": 193,
    "thumbnailHeight": 262,
    "title": "Mountain Ranges during Golden Hour - Free Stock Photo",
    "origin": "www.pexels.com",
    "contentUrl": "https://www.pexels.com/photo/mountain-ranges-during-golden-hour-694636/"
  }
]
```

#### Output Schema

```json
{
  "query": { "type": "string", "description": "The search query used" },
  "imageUrl": { "type": "string", "description": "Direct URL to the full-resolution image" },
  "imageWidth": { "type": "integer", "description": "Width of the full-resolution image in pixels" },
  "imageHeight": { "type": "integer", "description": "Height of the full-resolution image in pixels" },
  "thumbnailUrl": { "type": "string", "description": "URL of the Google-cached thumbnail" },
  "thumbnailWidth": { "type": "integer", "description": "Width of the thumbnail in pixels" },
  "thumbnailHeight": { "type": "integer", "description": "Height of the thumbnail in pixels" },
  "title": { "type": "string", "description": "Page title of the website containing the image" },
  "origin": { "type": "string", "description": "Domain of the website where the image is hosted" },
  "contentUrl": { "type": "string", "description": "URL of the web page containing the image" }
}
```

### Use cases

- **Image dataset building** - Collect large sets of images for research, analysis, or machine learning training
- **Brand monitoring** - Track how your brand visuals appear across the web
- **Competitor research** - Analyze competitor product images, marketing materials, and visual strategies
- **Content curation** - Find high-quality images for blogs, presentations, and social media
- **SEO & visual search analysis** - Monitor which images rank for specific keywords
- **E-commerce** - Research product photography trends and competitor listings

### Integrations

Connect Google Images Scraper with your existing tools and workflows:

- **Webhooks** - Get notified when a scrape finishes
- **API access** - Integrate results directly into your application
- **Scheduled runs** - Set up recurring scrapes to monitor image results over time
- Export to **Google Sheets**, **Slack**, **Zapier**, **Make**, and more

### FAQ

#### How many images can I scrape per query?

You can extract up to 500 images per search query. The default is 100. For most queries, Google Images returns hundreds of results.

#### What image data is included?

Every result includes the full-resolution image URL with dimensions, a Google-cached thumbnail URL with dimensions, the page title and domain of the source website, and a link to the web page containing the image.

#### Can I search for images in different languages?

Yes. You can use search queries in any language, including non-Latin scripts like Japanese, Chinese, Korean, Arabic, and more.

#### Can I run multiple queries at once?

Yes. Pass an array of queries and the scraper will process them sequentially, returning results for each query in a single dataset.

#### How fast is it?

The scraper typically extracts 100 images per query in under 15 seconds. Larger result sets (200-500) take proportionally longer due to pagination.

#### What format can I export the data in?

Results can be exported as JSON, CSV, Excel, XML, or accessed via the Apify API. You can also connect to Google Sheets, Slack, Zapier, and other integrations.

#### Does it handle Google's anti-bot protection?

Yes. The scraper uses stealth browser techniques to avoid detection and works reliably without requiring proxies.

# Actor input Schema

## `query` (type: `string`):

Image search query (e.g., "Alfons Mucha", "sunset landscape", "cats")

## `maxResults` (type: `integer`):

Maximum number of image results to extract

## `proxyConfiguration` (type: `object`):

Residential proxy is required — Google blocks image scraping from datacenter IPs.

## Actor input object example

```json
{
  "query": "Alfons Mucha",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `images` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "Alfons Mucha",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/google-images-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "Alfons Mucha",
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-images-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "Alfons Mucha",
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/google-images-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/google-images-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Images Scraper",
        "description": "Extract image data from Google Images search. Scrape image URLs, dimensions, thumbnails, page titles, origins, and content URLs for any search query.",
        "version": "1.0",
        "x-build-id": "7bahQLBWJ6eqmpqSy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~google-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-google-images-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~google-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-google-images-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~google-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-google-images-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Image search query (e.g., \"Alfons Mucha\", \"sunset landscape\", \"cats\")"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of image results to extract",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is required — Google blocks image scraping from datacenter IPs."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
