# Google Images Scraper — Full-Size Image URLs & Sources (`tortuga/google-images-scraper`) Actor

Scrape Google Images for any search term and country: full-size image URL, width/height, thumbnail, title, source page and site, license info, with size, color, type, time, usage-rights filters.

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

## Pricing

$2.50 / 1,000 image scrapeds

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 — Full-Size Image URLs & Sources

Scrape **Google Images** results for any search term and country: the **full-size image URL** (not just the
thumbnail), width and height, Google's thumbnail, the image title, the **source page URL**, domain and site name,
file size, dominant color and, when Google shows it, the **license** (Creative Commons / stock licence URL,
provider, creator, credit). Use Google's own filters: size, color, type (clip art, line drawing, GIF), time,
usage rights and SafeSearch. Export to JSON, CSV or Excel, or call it from your app via API.

The actor collects image *links and metadata*; it does not download the images.

### What data does it extract?

| Field | Example | Notes |
|---|---|---|
| `position` | `1` | Rank in Google's results for this search (and sub-search, see `searchVariant`) |
| `title` | `Eiffel Tower - Wikipedia` | Title Google shows under the image |
| `imageUrl` | `https://upload.wikimedia.org/.../Golden_retriever_stehfoto.jpg` | Full-size image on the source site |
| `imageWidth`, `imageHeight` | `3000`, `2000` | Original size in pixels |
| `thumbnailUrl` | `https://encrypted-tbn0.gstatic.com/images?q=tbn:...` | Google's thumbnail |
| `thumbnailWidth`, `thumbnailHeight` | `547`, `365` | |
| `sourceUrl` | `https://commons.wikimedia.org/wiki/File:Golden_retriever_stehfoto.jpg` | Page the image is on |
| `sourceDomain` | `commons.wikimedia.org` | |
| `sourceName` | `Wikimedia Commons` | Site name Google shows |
| `imageId` | `D6RW5KcSwZ0-zM` | Google's image id (stable; used for deduplication and monitoring) |
| `fileSize` | `2.1MB` | As Google labels it |
| `dominantColor` | `rgb(208,189,170)` | Google's placeholder color |
| `licenseUrl` | `https://creativecommons.org/licenses/by/3.0` | Only when Google shows licence details ("Licensable" badge) |
| `licenseAcquireUrl` | `https://www.gettyimages.com/detail/photo/...` | Where to get / license the image |
| `licenseProvider` | `Getty Images` | |
| `creator`, `credit`, `copyrightNotice` | `Luka Magic / 500px`, `©Getty Images, credit: ...` | Image credit as published in the image metadata |
| `isVideo`, `videoDuration` | `true`, `1:02` | Video thumbnails (TikTok, Instagram, YouTube) Google mixes into the results |
| `searchTerm`, `searchVariant`, `page` | `eiffel tower`, `as asked`, `2` | Which search, sub-search and Google page the image came from |
| `country`, `language`, `scrapedAt` | `gb`, `en`, `2026-10-11T22:06:54Z` | |

Related searches and refinement chips Google shows for each term ("Puppy", "Cute", "golden retriever black", ...)
are saved for free in the key-value store record `RELATED_SEARCHES`.

#### Example output

```json
{
  "position": 122,
  "title": "Eiffel Tower Guided Tours | Paris Insiders Guide",
  "imageUrl": "https://www.parisinsidersguide.com/image-files/eiffel-tower-upshot-dramatic-sky-gyg-1000-2x1.jpg",
  "imageWidth": 1000,
  "imageHeight": 500,
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSIgOYDcK6lwBDHkE6PRlVWD_7F-BxEiAH06JNKcPjORQ&s=10",
  "thumbnailWidth": 632,
  "thumbnailHeight": 316,
  "sourceUrl": "https://www.parisinsidersguide.com/eiffel-tower-guided-tours.html",
  "sourceDomain": "www.parisinsidersguide.com",
  "sourceName": "Paris Insiders Guide",
  "imageId": "jtz9WGYDG_kPfM",
  "fileSize": "246KB",
  "dominantColor": "rgb(232,194,149)",
  "licenseUrl": null,
  "licenseAcquireUrl": null,
  "licenseProvider": null,
  "creator": null,
  "credit": null,
  "copyrightNotice": null,
  "isVideo": false,
  "videoDuration": null,
  "searchTerm": "eiffel tower",
  "searchVariant": "as asked",
  "page": 2,
  "country": "gb",
  "language": "en",
  "scrapedAt": "2026-10-11T22:07:01Z"
}
```

### How to scrape Google Images

1. Enter one or more **Search terms** (e.g. `golden retriever`, `modern kitchen interior`).
2. Pick the **Country** (google.com, google.co.uk, google.de, ...) and optionally the language.
3. Optionally set Google's filters: **Size** (large / medium / icon), **Color** (black and white, transparent or a
   color), **Type** (clip art, line drawing, GIF), **Time** (past 24 hours / week / month / year), **Usage
   rights** (Creative Commons, commercial & other licenses) and **SafeSearch**.
4. Set **Max images** and run. You can also paste Google Images URLs into **Google Images URLs**; their search
   term, country, language, `tbs` filters and SafeSearch setting are reused.

Example input:

```json
{
  "queries": ["golden retriever"],
  "country": "us",
  "imageSize": "large",
  "usageRights": "creativeCommons",
  "maxItems": 200
}
```

### How many images can I get per search?

Google's results page shows **50-100 images**; the next pages (`start=10`, `20`, ...) add about 100 more each
until Google answers with an empty page. In our tests that was **165 images** for "golden retriever" (pages 1-3,
page 4 empty) and **300 images** in 3 pages for "eiffel tower" in the UK. When a search runs dry before **Max
images**, the actor runs **sub-searches** with the Google filters you left open (large, medium, past year, past
month, clip art, line drawing, GIF, black and white, transparent, each color, licences, icon) and removes
duplicates by Google's image id; `searchVariant` tells you which sub-search found an image and `position` is the
rank inside it. **Max Google pages per search term** (default 10) caps how many Google pages each term may use.

### How much does it cost?

You pay **$0.0025 per image** saved (the `Image scraped` event) plus Apify platform usage: each Google page is one
request through Apify's GOOGLE_SERP proxy (**about $0.0025 per page of 50-100 images**) and a little compute.
For 1,000 images that is about $2.50 in events + ~$0.03-0.05 SERP proxy + ~$0.02 compute and storage = **~$2.55-2.60 per
1,000 images**, everything included. Our test run of 250 UK images used $0.012 of platform usage in total (3 Google pages).

### Does it need a Google account, an API key or a browser?

No. It reads Google's normal results pages over HTTP through Apify's GOOGLE_SERP proxy (Google answers ordinary
datacenter and residential requests with a JavaScript wall). No login, no Google API key, no headless browser. The
proxy is chosen automatically; you do not need to configure anything.

### Can I search Google Images in other countries and languages?

Yes. **Country** selects the Google domain and pins the location (Google's `uule` location parameter), so you get
what people in that country see, e.g. more `.co.uk` sources for a UK search. **Language** sets Google's interface
language (`hl`). Answers Google localises to the wrong country are detected and retried.

### Monitor changes on a schedule

Turn on **Only new or changed items** and save the input as a task with a Schedule (e.g. daily). The actor
remembers which images earlier runs of the same search returned (by Google's image id) and outputs only **new
images**; images seen before are not saved and not charged. Each output image gets `changeType: "new"` (images do
not "change", so `previousValues` never appears here). Combine it with **Time: past week** to follow fresh images
for a brand, product or topic. Use **Monitoring key** to keep several schedules on the same search separate; **Max
images** is then the number of images checked per run.

### Is it legal to scrape Google Images?

The actor collects publicly visible search results (image links, titles, source pages and the credit lines
publishers attach to their images) that Google shows to anyone without logging in; it does not download images.
Images found this way are usually copyrighted by their owners: check the `licenseUrl` / source page before you
reuse an image, and check Google's terms and the laws that apply to your use case.

### Limits

- Google's **Type: Photo** and **Face** filters are gone from its Tools menu, and Google no longer honours
  `itp:photo` (tested: the page shows "Any type"); the actor offers the types Google still has.
- Licence fields are filled only for images Google marks as licensable (stock sites, Wikimedia, some
  photographers); for most images they are `null`. `fileSize` is Google's rounded label.
- Depth per search depends on Google (165-300+ images per search in tests); sub-searches go further but the
  later ones are narrower.
- SafeSearch "Google default" blurs explicit images in the browser but still lists them; choose "Filter explicit
  results" to remove them.

# Actor input Schema

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

One Google Images search per term, as you would type it on Google, e.g. "golden retriever", "modern kitchen interior", "Eiffel Tower at night".

## `maxItems` (type: `integer`):

Stop after this many images in total (you pay per image saved). Google shows about 150-170 images per search; above that the actor adds sub-searches with Google's own filters (see 'Max Google pages per search term').

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

Which country's Google is searched (google.com for the US, google.co.uk, google.de, ...). Results are pinned to this country.

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

Google interface language code, e.g. en, de, fr, es. It can change which images Google ranks first.

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

Google's size filter (Tools > Size).

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

Google's color filter (Tools > Color).

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

Google's type filter (Tools > Type). Google no longer offers 'Photo' or 'Face'.

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

Google's time filter (Tools > Time): images Google found in this period.

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

Google's usage-rights filter (Tools > Usage rights). Check each image's license (licenseUrl) before reusing it.

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

Google's default blurs explicit images (they are still listed); 'Filter' removes explicit results; 'Off' shows everything.

## `maxPagesPerQuery` (type: `integer`):

Google shows 50-100 images on the first page, about 100 more on the second and a few dozen on the third (~150-170 per search). After that the actor runs sub-searches with Google's own filters you left open (large, medium, past year, past month, clip art, line drawing, GIF, colors, ...), removing duplicates. Each page is one Google SERP proxy request (about $0.0025, billed by Apify as proxy usage). It stops early when pages stop adding new images.

## `startUrls` (type: `array`):

Optional: Google Images search URLs, e.g. https://www.google.com/search?q=golden+retriever\&udm=2\&tbs=isz:l. The q, gl, hl, tbs (filters) and safe parameters are reused.

## `onlyNewOrChanged` (type: `boolean`):

Remember what earlier runs of this search returned and output only new items or items whose price/status changed. Use with a Schedule; unchanged items are not charged. For Google Images: only images that earlier runs of this watch have not returned (by Google's image id); Max images is then the number of images checked per run.

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

Name for this watch, so several schedules on the same search stay separate; defaults to a key derived from the search input

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

Google Images loads only through Apify's GOOGLE_SERP proxy group (Google blocks plain datacenter and residential requests with a JavaScript wall). The actor always uses it. Apify bills it as proxy usage, about $0.0025 per Google page (50-100 images).

## Actor input object example

```json
{
  "queries": [
    "golden retriever"
  ],
  "maxItems": 100,
  "country": "us",
  "language": "en",
  "imageSize": "any",
  "imageColor": "any",
  "imageType": "any",
  "timePeriod": "any",
  "usageRights": "any",
  "safeSearch": "blur",
  "maxPagesPerQuery": 10,
  "onlyNewOrChanged": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# 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"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tortuga/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"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("tortuga/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"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call tortuga/google-images-scraper --silent --output-dataset

```

## MCP server setup

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