# Google Images Scraper: Image URLs, Sizes, Sources (`datagleaner/google-images-scraper`) Actor

Scrape Google Images results for any search in 43 countries: original image URL, width and height, title, source page and domain, thumbnail, file size and dominant color. Up to ~300 images per query, Google's size, type, color, time and license filters, no browser. $0.30 per 1,000 images.

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

## Pricing

$0.30 / 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.

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

## Google Images Scraper: Image URLs, Sizes, Sources

**Google Images Scraper** turns any Google Images search into a clean table of images. Type a query, such as `golden retriever puppy`, `modern kitchen design` or `桜 写真`. For each image you get the **direct URL of the full-size original**, its width and height in pixels, the title, the page it appears on and that site's domain and name, Google's thumbnail, the file size and the image's dominant color. It covers **43 countries**, returns **up to about 300 images per query** and supports Google's own **size, type, color, time and usage-rights filters**. There is no browser and no login to set up. It costs **$0.30 per 1,000 images**, with no start fee.

### What you can do with it

- **Build image datasets.** Collect hundreds of labelled images per query for computer vision, AI training or evaluation sets. Each row has the original URL, exact pixel size and file size, so you can filter before you download.
- **Bulk image search.** Run a list of queries (products, places, species, landmarks) and get every result in one dataset, instead of clicking through Google Images by hand.
- **Find large or licensed images.** Combine `imageSize: large`, `imageType: photo` or `usageRights: creativeCommons` to shortlist images worth checking for reuse.
- **SEO and brand monitoring.** See which sites rank in Google Images for your keywords, where your product photos appear, and which domains outrank you (`sourceDomain`, `position`).
- **Visual market research.** Pull what Google shows for a style, product or trend in different countries, and use `dominantColor` to compare palettes.
- **Feeds for AI agents and apps.** Plain JSON with the same field names for every query and country, ready for a spreadsheet, a database or an LLM.

### Input

| Field | Type | What it does |
|---|---|---|
| `queries` | list of text | Searches as you would type them into Google Images, in any language. Operators such as `site:unsplash.com` work too. Each query returns its own rows. |
| `maxImagesPerQuery` | number | Default 100, max 300. The run pages through Google Images until it has this many. |
| `country` | code | Where the search runs: `us` (default), `uk`, `de`, `fr`, `jp`, `in`, `br` and 36 more. It shifts which local sites rank. |
| `language` | code | Google's interface language, default `en`. Use the language of your query (`ja`, `de`, `es`...) for the most local results. |
| `safeSearch` | true/false | Google's SafeSearch filter for explicit images. On by default. |
| `imageSize` | choice | `large`, `medium` or `icon`. |
| `imageType` | choice | `photo`, `clipart`, `lineart`, `animated` (GIFs) or `face`. |
| `imageColor` | choice | `color`, `grayscale`, `transparent`, or a dominant color: `red`, `orange`, `yellow`, `green`, `teal`, `blue`, `purple`, `pink`, `white`, `gray`, `black`, `brown`. |
| `timePeriod` | choice | `day`, `week`, `month` or `year`: only images Google found in that period. |
| `usageRights` | choice | `creativeCommons` or `commercial` (commercial and other licenses). |
| `maxConcurrency` | number | How many queries run in parallel. Default 5. |

Example:

```json
{
  "queries": ["golden retriever puppy", "modern kitchen design"],
  "maxImagesPerQuery": 200,
  "country": "us",
  "imageSize": "large",
  "imageType": "photo"
}
```

An empty input `{}` runs a small example (5 images for "golden retriever puppy"), and the status message says so.

### Output

One row per image, in Google's order (`position`). Example:

```json
{
  "position": 1,
  "imageUrl": "https://www.muenchen.travel/var/ger_muc/storage/images/8/9/4/7/2427498-988-ger-DE/c4cb10e4e277-weihnachtsmarkt-8973-foto-lukas-barth-3000.jpg",
  "width": 3000,
  "height": 2000,
  "title": "Weihnachtsmärkte und Christkindlmärkte München 2026",
  "sourcePageUrl": "https://www.muenchen.travel/artikel/maerkte-feste/weihnachtsmaerkte-in-muenchen",
  "sourceDomain": "www.muenchen.travel",
  "sourceName": "Einfach München",
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSsMIzELynRlsQq7uYh1SksUYRMgxliE40miitVrUTkqg&s=10",
  "thumbnailWidth": 547,
  "thumbnailHeight": 365,
  "fileSize": "584KB",
  "fileSizeBytes": 598016,
  "dominantColor": "#804a2d",
  "publishedAgo": null,
  "imageId": "Zc9NVZhJgfowKM",
  "query": "weihnachtsmarkt münchen",
  "country": "de",
  "language": "de",
  "filters": "isz:l,itp:photo",
  "page": 1,
  "scrapedAt": "2026-10-21T19:07:05+00:00"
}
```

| Field | What it holds |
|---|---|
| `imageUrl`, `width`, `height` | Direct link to the full-size original on its host site, and its size in pixels. |
| `title` | The title Google shows for the image, usually the source page's title. |
| `sourcePageUrl`, `sourceDomain`, `sourceName` | The page the image appears on, its domain, and the site name Google shows. |
| `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight` | Google's hosted thumbnail and its size. Always loads, even when the original's host blocks hotlinking. |
| `fileSize`, `fileSizeBytes` | File size as Google shows it ("378KB") and the same in bytes (approximate, as Google rounds it). |
| `dominantColor` | The image's main color as a hex code. |
| `publishedAgo` | How long ago Google found the image ("2 days ago"). Mostly filled when you use `timePeriod`. |
| `imageId` | Google's id for the image, unique within a query. |
| `query`, `country`, `language`, `filters`, `page`, `scrapedAt` | Where the row came from and when. `filters` is Google's filter string, e.g. `isz:l,itp:photo`. |

Fill rates measured on Apify over 2,480 images in 5 countries (2026-10-22): `imageUrl`, `width`, `height`, `title`, `sourcePageUrl`, `sourceDomain`, `sourceName`, `thumbnailUrl`, `fileSize` and `dominantColor` 100%. `publishedAgo` 1-5% without a time filter, about 20% with one.

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

You pay per image saved to the dataset. This price is final:

| Event | Price | Per 1,000 |
|---|---|---|
| `image`: one image row | $0.0003 | $0.30 |

There is no start fee. Nothing is charged for failed pages, retries or repeated images. Platform usage is included in the price. The run stops by itself when it reaches your **maximum total charge**.

Examples:

- **One query, first 100 images:** **$0.03**.
- **An image dataset:** 50 queries × 300 images = 15,000 images = **$4.50**.
- **Weekly brand check** of 20 keywords × 100 images for a month: 8,000 images = **$2.40**.

### Limits

- **About 300 images per query.** Google Images stops paging after about 300 to 370 unique images for a busy query. For more, add related queries (synonyms, other languages, `site:` searches) or other countries.
- **Original URLs live on other sites.** `imageUrl` points to the host site, which may later move the file or refuse hotlinking. `thumbnailUrl` is served by Google and always loads. This Actor does not download the image files.
- **Speed.** Each Google page holds 50 to 100 images and takes 5 to 70 seconds. On Apify, 4 UK queries of 300 images (1,155 images) took under 2 minutes. Queries run in parallel (`maxConcurrency`).
- **Order.** Rows come in Google's order. Paging comes from Google's own pages, so a deep query can end a little under 300 when Google has no more.
- **Licenses.** `usageRights` is Google's own license filter. Always check the license on the source page before you reuse an image.
- Google can change its pages at any time. The Actor retries failed pages on a fresh connection and says in the status message when a query got no answer.

### Use with Python

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("datagleaner/google-images-scraper").call(
    run_input={"queries": ["golden retriever puppy"], "maxImagesPerQuery": 100, "imageSize": "large"}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item["position"], item["width"], item["height"], item["imageUrl"])
```

That run returns 100 images for $0.03.

### Use with JavaScript / Node.js

```js
// npm install apify-client
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('datagleaner/google-images-scraper').call({
    queries: ['modern kitchen design'],
    country: 'uk',
    maxImagesPerQuery: 300,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const img of items) console.log(img.position, img.sourceDomain, img.imageUrl);
```

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/google-images-scraper`

Minimal input:

```
{"queries": ["golden retriever puppy"], "maxImagesPerQuery": 20}
```

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`) and choose **Run an Actor and get dataset**. Set the Actor to `datagleaner/google-images-scraper` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items**.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**.
- **AI agents (MCP):** connect to `https://mcp.apify.com?tools=datagleaner/google-images-scraper`. In Claude Code:

  ```
    claude mcp add --transport http apify "https://mcp.apify.com?tools=datagleaner/google-images-scraper"
  ```

  Then run `/mcp` to sign in to Apify, and ask in plain language. For example: "Use the Google Images scraper to find 50 large Creative Commons photos of the Eiffel Tower and list their sizes and source sites."

### FAQ

**Is there a Google Images API?** Google offers no official API for Google Images results. This Actor works like one: send queries, get JSON back, through the Apify API, its clients, or the integrations above.

**How do I get the full-size image and not the thumbnail?** Use `imageUrl`. It is the original file on the host site, with its real `width` and `height`. `thumbnailUrl` is Google's small preview.

**Can I search Google Images in other countries and languages?** Yes. Set `country` (43 of them) and `language`, and write the query in that language, for example `桜 写真` with `country: jp` and `language: ja`.

**Can I filter by size, type, color, date or license?** Yes, with `imageSize`, `imageType`, `imageColor`, `timePeriod` and `usageRights`. They are Google's own filters and can be combined.

**How many images can I get per search?** Up to about 300, which is as far as Google Images pages. Split a broad subject into narrower queries for more.

**Does it download the images?** No. It returns the URLs, sizes and metadata. Download the files yourself from `imageUrl` (or `thumbnailUrl`) if you need them, and respect each image's license.

**Do I need a Google account, API key or proxy?** No. Everything runs on Apify. You only need an Apify account.

### Responsible use

This Actor collects only what Google Images shows publicly: image links, sizes, titles and the pages they come from. Images are usually protected by copyright, and some show people. **You** are responsible for how you use the results, including copyright and licensing, and any data protection rules that apply to images of people where you work. Check each image's license on its source page before you reuse it. This is not legal advice.

### Feedback

If this Actor saved you time, a rating on its Store page helps others find it. Problems or requests: open an issue on the Issues tab.

# Actor input Schema

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

What you would type into Google Images, in any language: a subject (golden retriever puppy), a product or brand (Eames lounge chair), a place, or a query with operators such as site:unsplash.com. One row per image found.

## `maxImagesPerQuery` (type: `integer`):

Stop each query after this many images. Google Images shows about 250-300 images for a busy query (page 1 holds 50-100).

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

The country Google Images searches from (the search is placed in its largest city). It shifts which local sites and pages rank, e.g. jp favors Japanese sites.

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

Google interface language as a code (en, de, fr, es, ja...). Use the language of your query for the best local results.

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

Filter explicit images, as Google's SafeSearch does. Turn off for unfiltered results.

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

Only images of this size (Google's Size filter).

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

Only images of this type (Google's Type filter).

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

Only images in this color scheme or with this dominant color.

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

Only images Google found within this period. Rows then carry a publishedAgo label such as '2 days ago'.

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

Only images Google lists with this kind of license. Always check the license on the source page before reuse.

## `maxConcurrency` (type: `integer`):

How many queries run at once. Each Google page takes 5-70 seconds, so more parallel queries finish a long list sooner.

## Actor input object example

```json
{
  "queries": [
    "golden retriever puppy",
    "modern kitchen design"
  ],
  "maxImagesPerQuery": 10,
  "country": "us",
  "language": "en",
  "safeSearch": true,
  "imageSize": "",
  "imageType": "",
  "imageColor": "",
  "timePeriod": "",
  "usageRights": "",
  "maxConcurrency": 5
}
```

# 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": [
        "golden retriever puppy",
        "modern kitchen design"
    ],
    "maxImagesPerQuery": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/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": [
        "golden retriever puppy",
        "modern kitchen design",
    ],
    "maxImagesPerQuery": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/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": [
    "golden retriever puppy",
    "modern kitchen design"
  ],
  "maxImagesPerQuery": 10
}' |
apify call datagleaner/google-images-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagleaner/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/tcwfjKQ58Xh2M73dS/builds/qRLVljOqYfDMexDNC/openapi.json