# Google Images Scraper: Image Search Results & URLs (`kaleidoscopelabs/google-images-scraper`) Actor

Google Images results in bulk for any keyword, country and language: each image's original URL, width and height, thumbnail, title, source page and site, file size and dominant color, in Google's order. Filter by size, color, type, time and usage rights. Use the API or paste a Google Images link.

- **URL**: https://apify.com/kaleidoscopelabs/google-images-scraper.md
- **Developed by:** [Kaleidoscope Labs](https://apify.com/kaleidoscopelabs) (community)
- **Categories:** SEO tools, E-commerce
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 images

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What can Google Images Scraper do?

**Google Images Scraper: scrape Google Images search results for any keyword, country and language, with each image's original URL and size, thumbnail, title, source page and site, as data you can export, schedule and call from an API.**

![A Google Images search for wooden coffee table in the US, as rows: each image's place, its shape and size, its file size and the site it is on; 20 images in all.](https://assets.kaleidoscopelabs.io/afy/google-images/search-as-rows.75fdb570.png)

- 🖼️ **Image results:** up to 400 images per search, in Google Images' order, each with its original URL, width and height.
- 🔗 **Where each image lives:** the page it is on, its site and the site's name, as Google Images shows them.
- 🎨 **Details:** Google's thumbnail, the file size and the image's dominant color.
- 🌍 **Any country and language:** set the country and language Google Images searches for.
- 🧰 **Google Images' filters:** size, color, type, time and usage rights (Creative Commons or commercial licenses), and SafeSearch.
- 🔎 **Google Images links:** paste a search link and its country, language and filters are kept.

Run it from Apify Console, through the API, on a schedule, or from an AI agent. The prefilled input reads one search, so you can see the output before a larger run.

| You want to | Use | What it costs |
|---|---|---|
| Find the images Google shows for a product or a place | A search, with its country | $1.50 per 1,000 images |
| Find images you may reuse | Usage rights: Creative Commons | the same |
| Collect transparent icons or clip art | Color: transparent, Type: clip art | the same |

### What data can you get from Google Images?

One record per image.

![One image record, shortened: the search it came from, its position, title, original URL and size, the page and site it is on, and the rest of its fields.](https://assets.kaleidoscopelabs.io/afy/google-images/image-record.542bdd32.png)

| Data | Field |
|---|---|
| The image's place in Google Images' results, from 1; Google's own, so a page that held fewer images leaves gaps (1–50, then 101–150) | `position` |
| The original image's URL, width and height | `imageUrl`, `imageWidth`, `imageHeight` |
| Google's thumbnail and its size | `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight` |
| The image's title, as Google Images shows it | `title` |
| The page the image is on, its site and the site's name | `pageUrl`, `domain`, `sourceName` |
| The file size as Google shows it, and the dominant color | `fileSize`, `dominantColor` |
| Google Images' ID of the image | `imageId` |
| The search on Google Images, to open in a browser | `googleImagesUrl` |
| What the record lacks and why | `missing` |

Every record also carries the search it came from: `query`, `line`, `country`, `language` and `filters`. The Actor stores URLs and details only: it never downloads an image.

### How to use Google Images Scraper

1. Create a free Apify account and open Google Images Scraper.
2. In **Searches**, enter one search per line, as you would type it in Google Images, or paste a Google Images search link.
3. Choose the **Country** and **Language**, and how many **Results per search** you want (up to 400).
4. Set any of Google Images' **Filters**.
5. Click **Start**. Records appear in the Output tab; export them as JSON, CSV or Excel, or read them from the API.

### How much does it cost to scrape Google Images?

Google Images Scraper is priced per event, with no usage fees on top:

| Event | Price | When |
|---|---|---|
| Image | $1.50 per 1,000 | each image stored |

The platform also charges $0.00005 when a run starts. Prices shown are for Apify's free plan; on paid plans they are up to 30% lower.

| You read | It costs |
|---|---|
| 100 searches, 100 images each (10,000 images) | $15.00 |
| 50 searches, up to 400 images each (at most 20,000 images) | at most $30.00 |
| 1,000 searches, 20 images each (20,000 images) | $30.00 |
| The prefilled input (20 images) | $0.03 |

- **Apify's free plan credit of $5 a month** covers about 3,300 images.
- **Not charged:** a search with no results, a search that repeats an earlier one in the same run (read once), and anything the run could not read. Set a maximum total charge in the run options to cap a run: the Actor stops before it.

### Input recipes

Each recipe is a complete input to paste.

#### Product images in one market

```json
{
  "queries": ["wooden coffee table"],
  "country": "US",
  "maxResults": 100
}
```

#### Images you may reuse: Creative Commons photos

```json
{
  "queries": ["mountain lake at sunrise"],
  "usageRights": "creativeCommons",
  "type": "photo",
  "size": "large"
}
```

#### Transparent icons

```json
{
  "queries": ["shopping cart icon"],
  "color": "transparent",
  "type": "clipart"
}
```

#### The same search in Germany, in German

```json
{
  "queries": ["Couchtisch Holz"],
  "country": "DE",
  "language": "de"
}
```

#### A Google Images link, as set on the site

```json
{
  "queries": ["https://www.google.com/search?q=wooden+coffee+table&udm=2&tbs=isz:l"]
}
```

### Output example

A record of a search for "coffee mug" in the US (November 2026):

```json
{
  "query": "coffee mug",
  "line": 2,
  "country": "US",
  "language": "en",
  "filters": {},
  "position": 3,
  "title": "FÄRGKLAR mug, light pink, 14 oz - IKEA",
  "imageUrl": "https://www.ikea.com/us/en/images/products/faergklar-mug-light-pink__1397576_pe967644_s5.jpg?f=s",
  "imageWidth": 600,
  "imageHeight": 600,
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSSt7_tQ5GFweY8xwJ-WivkRnyIWDN4ZxPuxS4HaRwBQw&s=10",
  "thumbnailWidth": 554,
  "thumbnailHeight": 554,
  "pageUrl": "https://www.ikea.com/us/en/p/faergklar-mug-light-pink-50604880/",
  "domain": "www.ikea.com",
  "sourceName": "IKEA",
  "fileSize": "25KB",
  "dominantColor": "#b09a96",
  "imageId": "jIVbAlTPi5AJ2M",
  "googleImagesUrl": "https://www.google.com/search?gl=us&hl=en&q=coffee+mug&safe=active&udm=2",
  "missing": []
}
```

### Integrations and API

Use it as a Google Images API: start a run from any language and read its records as JSON, CSV or Excel.

- **Make, Zapier, n8n:** start a run and send its records on when it finishes.
- **Google Sheets, webhooks, the Apify API and clients** for JavaScript and Python.
- **AI agents:** through Apify's MCP server, an agent can call the Actor as a tool.

Run a recipe and get its records in one call (with your Apify API key in the APIFY_TOKEN variable):

```bash
curl -X POST "https://api.apify.com/v2/acts/kaleidoscopelabs~google-images-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"queries": ["wooden coffee table"], "country": "US", "maxResults": 20}'
```

#### Building on this Actor

- **Output stability:** fields are added, never renamed or removed without a new major version; every change is in the changelog.
- **What a run's end means:** a finished run read every search it was given, or names what it could not read in the run's `RUN_SUMMARY` record (`searchesNotRead`, and `searchesReadInPart` for a search whose later pages could not be read) and says so in its closing status; searches without results are listed in `searchesWithoutResults`, and searches whose images start at Google Images' second page in `searchesFromSecondPage`. An input the Actor cannot read ends the run SUCCEEDED with nothing read and no image charged, its reason as the status message and in `RUN_SUMMARY`'s `inputError`; on a normal run `inputError` is null.
- **Cost per call:** the event and its price are on the Pricing tab; what is not charged is listed above; your maximum charge holds.
- **Notice:** price changes follow Apify's 14-day notice.

### For AI agents

Connect an MCP client (Claude, Cursor and others) to `https://mcp.apify.com?tools=kaleidoscopelabs/google-images-scraper` with your Apify API key, then ask, for example:

- "Find 20 large Creative Commons photos of mountain lakes."

- "Which sites show up in Google Images for 'wooden coffee table' in the US?"

- **Minimal input:** `{"queries": ["wooden coffee table"]}` reads up to 100 images in the US, in English, with SafeSearch on.

- **Fields to read:** `position`, `imageUrl`, `imageWidth`, `imageHeight`, `pageUrl`, `domain`, `title`; `missing` for what a record lacks.

- **What to know:**
  - A Google Images link's own country, language, filters and SafeSearch win over the form's for its line.
  - A search with no results stores nothing and is listed in `RUN_SUMMARY`'s `searchesWithoutResults`.
  - An empty dataset with `inputError` set in `RUN_SUMMARY` is an input mistake, not "no results".

### Tips

- **Country matters:** Google Images' results follow the country; the language changes the titles Google shows and some of the results.
- **Links keep their settings:** set the filters on Google Images and paste its link.
- **Check the license:** the usage-rights filter is Google's; check each image's license on its page before you use it.
- **A long input:** a run that would not finish in its timeout says so at its start, reads what fits and lists the searches left; give it a longer timeout or split the input.

Did it save you time? A rating on this page helps others find it; an Issue tells us what to fix.

### FAQ

#### Is there an official Google Images API?

Google offers no API for Google Images' results. Its Custom Search JSON API searched the sites set up in a Programmable Search Engine; Google has closed it to new customers and ends it on 1 January 2027. This Actor reads what Google Images shows anyone for a search and returns it as records you call from the Apify API.

#### Does it download the images?

No. It stores each image's URLs and details; the images stay on their sites.

#### Why does a record lack a field?

Google Images does not list that detail for the image; the record names the field in `missing` with the reason "notGiven".

#### Why did a search return fewer images than I asked for?

In our tests (November 2026), Google Images showed about 150 to 400 images for a search, fewer for some; you get as many as it shows, up to your number. Some of Google Images' pages hold fewer images; the Actor goes on to the next page for the rest. Images that sit inside documents, such as PDFs, have no image URL and are left out. You pay only for the images stored.

![How far three searches went, a dot per image and a block per page: water bottle 324 images, chair 194, plastic storage bins 205, each ending where Google Images had no more.](https://assets.kaleidoscopelabs.io/afy/google-images/search-depth.07c5b954.png)

#### Why do some results start at position 101?

For some searches, mostly shopping ones, Google Images' first page of results comes without its images. The Actor then reads the search from its second page: the records keep Google's own positions, from 101, the run says so, and the search is listed in `RUN_SUMMARY`'s `searchesFromSecondPage`. Nothing is charged for the first page.

#### Why do my results differ from what I see in Google Images?

Google Images' results depend on the country, the language, SafeSearch and the time; the Actor searches without a signed-in account or your history, so its results are the ones Google shows anyone for that country and language.

#### Does it collect personal data?

It stores what Google Images shows anyone for a search: image and page URLs, titles and site names. It has no field about a person, but an image or a title can show one; if your results hold personal data, data-protection law (such as the GDPR) applies to what you do with them.

#### Is it legal to scrape Google Images?

The Actor reads only what Google Images shows anyone and stores links and details, never the images. Images are usually protected by their owners' copyright: check each image's license on its page before you reuse it. Whether your use of the data is lawful depends on what you do with it; if you are unsure, ask a lawyer.

### Limits

- Up to 400 images per search (in our tests Google Images showed about 150 to 400); 1,000 searches a run.
- Search by keyword or link; search by image is not offered.

### Other Actors

| You want to | Actor |
|---|---|
| See how search interest in a product moves through the year, and where it is searched most | Google Trends Scraper |

### Support and feedback

Open an issue on the Issues tab for a bug or a feature you need; we answer within 24 hours. If the Actor saves you time, bookmark it and leave a review in Apify Store: it helps others find it.

*Google Images Scraper is an independent tool, not affiliated with, endorsed by or sponsored by Google LLC. Google and Google Images are trademarks of Google LLC.*

# Changelog

This Actor's version history is a separate document: https://apify.com/kaleidoscopelabs/google-images-scraper/changelog.md

# Actor input Schema

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

One search a line, as you would type it in Google Images, or a Google Images search link (its country, language, filters and SafeSearch are kept for that line). A line that is neither is skipped and said in the log; a line that repeats an earlier one is read once.

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

How many images to store for each search, in Google's order: up to 400. Google Images shows a few hundred for most searches; you get as many as it shows, up to this number.

## `country` (type: `string`):

The country to search from, by its two-letter code such as US, GB or DE: Google Images' results differ by country. A search link's own country is kept for its line.

## `language` (type: `string`):

The language of Google's interface, by its code such as en, de or pt-BR: it changes the titles Google shows and some of the results.

## `size` (type: `string`):

Only images of this size, as Google Images' Tools menu offers.

## `color` (type: `string`):

Only images in color, in black and white, or with a transparent background.

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

Only photos, clip art, line drawings or animated images.

## `time` (type: `string`):

Only images Google found within this time.

## `usageRights` (type: `string`):

Only images Google lists under Creative Commons licenses, or under commercial and other licenses. Check each image's license on its page before you use it.

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

Filter explicit results, as Google's SafeSearch does. A search link's own setting is kept for its line.

## Actor input object example

```json
{
  "queries": [
    "wooden coffee table",
    "eiffel tower at night",
    "https://www.google.com/search?q=wooden+coffee+table&udm=2"
  ],
  "maxResults": 20,
  "country": "GB",
  "language": "en",
  "size": "any",
  "color": "any",
  "type": "any",
  "time": "any",
  "usageRights": "any",
  "safeSearch": true
}
```

# Actor output Schema

## `results` (type: `string`):

One record per image in the run's default dataset: its URLs and size, its page and site, and what the record lacks.

## `summary` (type: `string`):

What the run did: the searches read and the images stored, the searches without results, what could not be read, and the Ref to quote in an issue.

## `progress` (type: `string`):

The searches the run could not read: written when the platform moves the run and at its end, so a run moved or resurrected counts them once.

# 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": [
        "wooden coffee table"
    ],
    "maxResults": 20,
    "country": "US",
    "language": "en",
    "size": "any",
    "color": "any",
    "type": "any",
    "time": "any",
    "usageRights": "any"
};

// Run the Actor and wait for it to finish
const run = await client.actor("kaleidoscopelabs/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": ["wooden coffee table"],
    "maxResults": 20,
    "country": "US",
    "language": "en",
    "size": "any",
    "color": "any",
    "type": "any",
    "time": "any",
    "usageRights": "any",
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "wooden coffee table"
  ],
  "maxResults": 20,
  "country": "US",
  "language": "en",
  "size": "any",
  "color": "any",
  "type": "any",
  "time": "any",
  "usageRights": "any"
}' |
apify call kaleidoscopelabs/google-images-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kaleidoscopelabs/google-images-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/A80DZGGxAxYUeEg2g/builds/Gma0ygxC2MGhnch4Q/openapi.json