# Google Images Scraper - Image Search Results (`benthepythondev/google-images-scraper`) Actor

Search Google Images and export ranked image previews, titles, dimensions, source domains and publisher page URLs for visual research, SEO and content workflows.

- **URL**: https://apify.com/benthepythondev/google-images-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Marketing, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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 - Image Search Results

Search Google Images and turn the visible result grid into structured data. The Actor returns ranked Google-hosted preview URLs together with the result title, rendered dimensions, source domain, publisher page, query, and scrape timestamp. Use it for visual research, SEO audits, content discovery, source analysis, brand monitoring, mood-board preparation, or repeatable image-search workflows without maintaining a local browser.

The Actor runs a real Chromium browser because the current Google Images interface renders its result data with JavaScript. It handles the consent dialog, scrolls the results page, removes duplicate images, and stops at the limit you choose. Every output row keeps the publisher URL so you can inspect the original context and verify licensing before reusing an image.

### What you can collect

Each result can include:

- the search query and Google result rank;
- the visible result title or image alternative text;
- a high-resolution Google-hosted preview URL;
- the preview width and height reported by the browser;
- the publisher domain and source page URL;
- a stable result identifier when Google exposes one; and
- the UTC time when the result was collected.

Google Images is a discovery surface, not an image-license database. A result appearing in Google does not grant permission to reproduce it. Always open `source_url` and confirm the publisher's license, attribution requirements, and intended use. The Actor deliberately preserves that source link in every row.

### Common use cases

#### Visual SEO research

Compare which publishers and image formats appear for commercial or informational search phrases. Export rankings regularly and examine changes in source domains, titles, aspect ratios, or visible image themes. This is useful when researching image SEO opportunities, competitor coverage, and the visual intent behind a search query.

#### Content and design research

Build a structured reference set for editorial planning, product photography briefs, presentation design, or mood boards. The dataset gives your team a repeatable starting point while the source URL keeps the research traceable. It is safer and more useful than sharing unlabelled screenshots between collaborators.

#### Brand and asset monitoring

Search for a company, product, executive, event, or campaign name and store the ranked results on a schedule. Compare datasets over time to identify new publishers, unexpected imagery, outdated logos, or changes in the visible search landscape.

#### Publisher discovery

Find websites that rank visually for a topic. The `source_domain` and `source_url` fields can feed outreach research, content-gap analysis, publisher lists, or a manual rights-clearance workflow. The Actor does not contact publishers and does not bypass access controls.

#### Automation and reporting

Run a saved Apify Task daily or weekly, export results as JSON, CSV, Excel, XML, or RSS, and connect the dataset to Make, Zapier, n8n, Google Sheets, or your own application through the Apify API. Bounded defaults make scheduled runs predictable.

### Input

Use the following fields:

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array | One or more Google Images search phrases. |
| `maxResultsPerQuery` | integer | Maximum unique rows returned for each query. Default: 10. |
| `languageCode` | string | Google interface language such as `en`, `de`, `es`, or `fr`. |
| `countryCode` | string | Two-letter localization code such as `us`, `gb`, `de`, or `fr`. |
| `safeSearch` | boolean | Keeps Google SafeSearch enabled when true. |

Example input:

```json
{
  "queries": [
    "sustainable office architecture",
    "solar roof commercial building"
  ],
  "maxResultsPerQuery": 20,
  "languageCode": "en",
  "countryCode": "us",
  "safeSearch": true
}
````

For the most predictable runs, begin with 10 to 25 results per query. Larger limits require more scrolling and therefore more browser time. Split unrelated topics into separate saved Tasks when they need different schedules or localization settings.

### Output

Example dataset row:

```json
{
  "query": "sustainable office architecture",
  "rank": 1,
  "result_id": "example-result-id",
  "title": "Sustainable office building with a green facade",
  "image_url": "https://encrypted-tbn0.gstatic.com/images?q=...",
  "image_width": 640,
  "image_height": 426,
  "source_name": "Example Architecture",
  "source_domain": "example.com",
  "source_url": "https://example.com/sustainable-office-project",
  "scraped_at": "2026-07-11T12:00:00+00:00"
}
```

`image_url` is the preview delivered by Google Search, not a claim that the file is the publisher's original asset. Use `source_url` to inspect the original page. Browser-reported dimensions describe the loaded preview and may differ from the source file's native dimensions.

### How the Actor works

1. It validates and deduplicates the supplied queries.
2. It opens the localized Google Images result page in headless Chromium.
3. It handles common Google consent dialogs in several languages.
4. It waits for real image cards instead of treating a successful HTTP status as success.
5. It extracts the visible preview, source, title, dimensions, and result metadata.
6. It scrolls until the requested limit or a bounded stale-result threshold is reached.
7. It removes duplicate preview URLs and writes one dataset item per unique result.
8. It fails clearly if Google returns no usable rows, allowing scheduled-run monitoring to detect a real problem.

The Actor uses limited Apify permissions and only writes to its default dataset. It does not require a Google account, a Google API key, or user credentials.

### Pricing

This Actor uses pay-per-event pricing. There is a small Actor start charge and a flat charge for each unique result written to the default dataset. Duplicate cards and unusable rows are not pushed and therefore do not create result events. Check the current Store pricing panel before a large run and use `maxResultsPerQuery` to keep spend bounded.

### Reliability notes

Google can change result markup, localization, consent behavior, and traffic controls. This Actor checks for actual rendered image cards and raises an error on an empty extraction instead of silently returning a successful empty dataset. If one query has no results, try a broader phrase and verify that the selected country and language are appropriate.

For recurring monitoring, save the input as an Apify Task and enable failure notifications. Google rankings are personalized and dynamic; results can vary by time, language, country, and Google's own ranking experiments. Treat the dataset as a repeatable observation from the selected settings, not as a universal ranking guarantee.

### API example

Start a run with the Apify API:

```bash
curl -X POST "https://api.apify.com/v2/acts/benthepythondev~google-images-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["electric vehicle dashboard"],"maxResultsPerQuery":10,"countryCode":"us","languageCode":"en","safeSearch":true}'
```

When the run succeeds, read the default dataset through the API or use the Console export menu. Never place an Apify token in client-side code or a public repository.

### Frequently asked questions

#### Does the Actor download image files?

No. It returns structured metadata and the preview URL shown by Google. This keeps runs fast and lets you decide which source pages deserve manual review.

#### Are the images free to use?

Not necessarily. Google Images indexes many licensing models. Confirm rights and attribution on `source_url` before downloading, republishing, training on, or commercially using any asset.

#### Does it return the publisher's original image URL?

It returns the Google-hosted preview visible in search and the publisher page URL. The original file may be loaded or protected differently on the publisher's website, so the Actor does not label the preview as an original download.

#### Can I search several phrases in one run?

Yes. Add multiple values to `queries`. Each row includes its originating query and per-query rank.

#### Can I localize results?

Yes. Set `languageCode` and `countryCode`. Google still controls ranking and may use additional infrastructure signals, so localization is a strong hint rather than a legal or geographic guarantee.

#### Why did a run fail instead of returning zero rows?

An empty result can indicate a markup change, consent page, temporary traffic control, or genuinely empty query. Explicit failure makes automated monitoring safer than a misleading green run with no data.

### Related Actors

- [Unsplash Image Search Scraper](https://apify.com/benthepythondev/unsplash-image-search-scraper) for rich public Unsplash photo and photographer metadata.
- [Google Keyword Suggestions Scraper](https://apify.com/benthepythondev/google-keyword-suggestions-scraper) for related search-query discovery.
- [Google News Scraper](https://apify.com/benthepythondev/google-news-scraper) for ranked news-result monitoring.
- [Website Contact Extractor](https://apify.com/benthepythondev/website-contact-extractor) for contact discovery on selected publisher websites.

If this Actor produces useful data for your workflow, leave an honest Apify Store review. For support, include the run ID, a sanitized input example, the expected result, and what happened; do not post API tokens or private credentials.

Keywords: Google Images scraper, image search API, Google image results, visual SEO research, image source finder, image SERP scraper, content research automation, image monitoring, publisher discovery, Apify Google scraper.

# Actor input Schema

## `queries` (type: `array`):

One or more Google Images search phrases.

## `maxResultsPerQuery` (type: `integer`):

Maximum unique image results saved for each query.

## `languageCode` (type: `string`):

Google interface language, such as en, de, es or fr.

## `countryCode` (type: `string`):

Two-letter country code used to localize search results, such as us, de, gb or fr.

## `safeSearch` (type: `boolean`):

Keep Google SafeSearch enabled for the request.

## Actor input object example

```json
{
  "queries": [
    "mountain sunrise",
    "modern office interior"
  ],
  "maxResultsPerQuery": 10,
  "languageCode": "en",
  "countryCode": "us",
  "safeSearch": true
}
```

# Actor output Schema

## `results` (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 = {
    "queries": [
        "mountain sunrise",
        "modern office interior"
    ],
    "maxResultsPerQuery": 10,
    "languageCode": "en",
    "countryCode": "us",
    "safeSearch": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/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 = {
    "queries": [
        "mountain sunrise",
        "modern office interior",
    ],
    "maxResultsPerQuery": 10,
    "languageCode": "en",
    "countryCode": "us",
    "safeSearch": True,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/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 '{
  "queries": [
    "mountain sunrise",
    "modern office interior"
  ],
  "maxResultsPerQuery": 10,
  "languageCode": "en",
  "countryCode": "us",
  "safeSearch": true
}' |
apify call benthepythondev/google-images-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Images Scraper - Image Search Results",
        "description": "Search Google Images and export ranked image previews, titles, dimensions, source domains and publisher page URLs for visual research, SEO and content workflows.",
        "version": "1.0",
        "x-build-id": "E7dnMlsM6ZPB3Ak8V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~google-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-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/benthepythondev~google-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-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/benthepythondev~google-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Image search queries",
                        "type": "array",
                        "description": "One or more Google Images search phrases.",
                        "default": [
                            "mountain sunrise"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum results per query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum unique image results saved for each query.",
                        "default": 10
                    },
                    "languageCode": {
                        "title": "Language code",
                        "type": "string",
                        "description": "Google interface language, such as en, de, es or fr.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter country code used to localize search results, such as us, de, gb or fr.",
                        "default": "us"
                    },
                    "safeSearch": {
                        "title": "SafeSearch",
                        "type": "boolean",
                        "description": "Keep Google SafeSearch enabled for the request.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
