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

Scrape Google Images by keyword or URL: original image URL, width and height, source page, page title, domain, file type and thumbnail. All Google filters (size, color, type, file type, shape, usage rights, date), any country. No login or browser. From $0.70 per 1,000 images.

- **URL**: https://apify.com/eiv/google-images-scraper.md
- **Developed by:** [Eimantas V](https://apify.com/eiv) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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.
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

**Google Images Scraper** extracts image search results from **Google Images**: the **original image URL**, its **width and height**, the **page it is on**, that page's **title**, the **domain**, the **file type** and Google's **thumbnail**. Paste search terms or Google Images URLs, use any of Google's filters (size, color, type, file type, shape, usage rights, date), and get one row per image. No login, no API key, no browser, from **$0.70 per 1,000 images**.

```json
{
  "query": "golden retriever puppy",
  "position": 1,
  "imageUrl": "https://blog.ollie.com/wp-content/uploads/250506_Livingroom_SHOT-10_0173_FR-scaled.jpg",
  "imageWidth": 2560,
  "imageHeight": 1707,
  "title": "Golden Retriever: Pros, Cons & Diet Guide | Ollie",
  "pageUrl": "https://blog.ollie.com/breed-deets-golden-retriever/",
  "domain": "blog.ollie.com",
  "fileType": "jpg",
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRbrtNwKnE9g9GMxWrwJRdj6a2qZ-ewk6Ri2OYZ2NLl7GsX32lUZok3vVJK&s",
  "megapixels": 4.37,
  "orientation": "landscape"
}
```

**Benchmark: 4,195 images with page titles from 10 searches in 3 minutes 9 seconds at 256 MB, every request answered (measured on Apify, 2026-10-29).**

### What does Google Images Scraper do?

It searches Google Images the way a person does and turns the results into clean JSON, CSV or Excel. Give it keywords, Google operators or ready-made Google Images URLs, pick a country and language, narrow the results with Google's own filters, and it returns every image with the page it comes from. It is built for image datasets and AI training data, brand and product image monitoring, visual SEO research, content sourcing and as an image search tool for AI agents.

- **Any search, up to Google's limit.** Search terms, operators (site:, -word, "exact phrase") or pasted Google Images URLs with their filters. Up to 600 images per search, which is as many as Google shows.
- **The original, not just a thumbnail.** Every row has the full-size image URL on the website that hosts it, its pixel size, megapixels and orientation, plus Google's always-loadable thumbnail.
- **Where each image comes from.** The source page's URL, its domain and its title, so you know the context and who to ask about the licence.
- **Every Google Images filter.** Size (large, medium, icon, larger than 2-70 MP), color (full color, black and white, transparent, 12 single colors), type (photo, face, clip art, line drawing, animated), file type (JPG, PNG, GIF, WEBP, SVG, BMP, ICO), shape, Creative Commons or commercial licences, past day/week/month/year or a custom date range, SafeSearch, any country and interface language.
- **Only pay for images.** Searches with no images and searches Google refused cost nothing, and duplicates within a search are removed before you pay.
- **Drop-in for hooli/google-images-scraper.** The same input names (`queries`, `maxResultsPerQuery`) and the same output fields (`query`, `title`, `imageUrl`, `imageWidth`, `imageHeight`, `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight`, `origin`, `contentUrl`), so an existing integration works by changing the Actor ID.
- **Built for automation.** Schedules, the Apify API, webhooks, Make, Zapier, n8n, Google Sheets, and AI agents through Apify's MCP server.

### Why it is fast and cheap

Google Images in a desktop browser is a JavaScript application that scrapers usually drive with a headless browser or a paid SERP proxy. This Actor asks Google for the lightweight page it serves to simple phones instead: 20 images in about 23 KB, with the original image URL, source page and sizes in plain links, plus an 8 KB detail page per image for its page title. No browser, no paid proxy, so a search of 100 images takes a few seconds and the price stays low.

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

| Field | Example | What it is |
|---|---|---|
| `imageUrl` | `https://blog.ollie.com/.../SHOT-10_0173_FR-scaled.jpg` | The full-size original image |
| `imageWidth`, `imageHeight` | `2560`, `1707` | Size of the original in pixels |
| `title` | `Golden Retriever: Pros, Cons & Diet Guide \| Ollie` | Title of the page the image is on |
| `pageUrl` | `https://blog.ollie.com/breed-deets-golden-retriever/` | The page the image is on |
| `domain` | `blog.ollie.com` | That page's site |
| `fileType` | `jpg` | Image format |
| `thumbnailUrl` | `https://encrypted-tbn0.gstatic.com/images?q=tbn:...` | Google's thumbnail, always loadable |
| `thumbnailWidth`, `thumbnailHeight` | `275`, `183` | Thumbnail size |
| `megapixels` | `4.37` | Width x height in millions of pixels |
| `orientation` | `landscape` | landscape, portrait or square |
| `position` | `1` | Rank in Google Images for the search, duplicates removed |
| `page` | `1` | Which results page (20 images each) it was on |
| `query` | `golden retriever puppy` | The words searched |
| `correctedQuery` | `mountain landscape` | What Google searched instead when it autocorrected; else null |
| `imageId` | `eYoKU9jW-eRT6M` | Google's ID for the result |
| `searchUrl` | `https://www.google.com/search?q=...&tbm=isch...` | The search, to open in a browser |
| `input` | `golden retriever puppy` | Your search line exactly as entered |
| `scrapedAt` | `2026-10-29T12:00:00.000Z` | When this run collected the row |

### How to scrape Google Images

1. Click **Try for free** and type your searches into **Search queries**, one per line. A Google Images URL works too.
2. Set **Max images per query** (100 by default, up to 600). You pay per image, so this is also your cost cap.
3. Pick filters, country and language if you need them, then click **Start**. 100 images take about 10 seconds, 1,000 about a minute.
4. Open the **Output** tab, or download the results as JSON, CSV, Excel or HTML.

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

You pay per image returned, and the price drops on higher Apify plans:

| Apify plan | Per 1,000 images |
|---|---|
| Free | $1.20 |
| Starter | $1.00 |
| Scale | $0.85 |
| Business | $0.70 |

- 10 product searches of 100 images each (1,000 images) cost **$1.00** on the Starter plan.
- 50 brand searches of 600 images each (30,000 images) cost **$21.00** on the Business plan.
- A run also costs **$0.00005** to start. A search that fails, or finds nothing, costs nothing more. Page titles are included in the price.
- The Free plan's $5 monthly credit covers about **4,000 images**.

### Input

```json
{
  "queries": ["golden retriever puppy", "https://www.google.com/search?q=coffee+cup&tbm=isch&tbs=ic:trans"],
  "maxResultsPerQuery": 100,
  "imageSize": "large",
  "usageRights": "creativeCommons",
  "countryCode": "us"
}
```

| Field | Default | Notes |
|---|---|---|
| Search queries (`queries`) | `golden retriever puppy` | Search terms or Google Images URLs, one per line |
| Max images per query (`maxResultsPerQuery`) | 100 | Up to 600, Google's own limit |
| Max images in total (`maxItems`) | 10,000 | Cap for the whole run |
| Size, Color, Type, File type, Shape, Usage rights, Time | any | Google's Tools filters; a pasted URL keeps its own |
| From date / To date (`dateFrom`, `dateTo`) | none | Custom date range, YYYY-MM-DD |
| SafeSearch (`safeSearch`) | on | Off returns unfiltered results |
| Country (`countryCode`), Interface language (`languageCode`) | United States, the country's language | Google's gl and hl |
| Search exactly as typed (`exactQuery`) | off | Turns off Google's autocorrect |
| Page titles and file types (`includePageDetails`) | on | One small extra request per image, included in the price |
| Proxy | Apify Proxy (datacenter) | Switches to it only when Google rate-limits the run's own address; Residential is used only if you choose it, and only for results pages |

### Output

Each image is one row in the dataset. The **Overview** view shows the image, page title, links and size; **Size and format** and **Search and errors** show the rest, and every export includes all fields.

```json
{
  "recordType": "image",
  "query": "golden retriever puppy",
  "position": 1,
  "imageUrl": "https://blog.ollie.com/wp-content/uploads/250506_Livingroom_SHOT-10_0173_FR-scaled.jpg",
  "imageWidth": 2560,
  "imageHeight": 1707,
  "title": "Golden Retriever: Pros, Cons & Diet Guide | Ollie",
  "pageUrl": "https://blog.ollie.com/breed-deets-golden-retriever/",
  "domain": "blog.ollie.com",
  "fileType": "jpg",
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRbrtNwKnE9g9GMxWrwJRdj6a2qZ-ewk6Ri2OYZ2NLl7GsX32lUZok3vVJK&s",
  "thumbnailWidth": 275,
  "thumbnailHeight": 183,
  "megapixels": 4.37,
  "orientation": "landscape",
  "imageId": "eYoKU9jW-eRT6M",
  "page": 1,
  "correctedQuery": null,
  "searchUrl": "https://www.google.com/search?q=golden+retriever+puppy&tbm=isch&hl=en&gl=us&ie=UTF-8&oe=UTF-8&safe=active",
  "input": "golden retriever puppy",
  "scrapedAt": "2026-10-29T11:55:27.146Z",
  "origin": "blog.ollie.com",
  "contentUrl": "https://blog.ollie.com/breed-deets-golden-retriever/"
}
```

A search that cannot be read becomes a row with `"recordType": "error"` and an `errorCode` instead of failing the whole run:

| `errorCode` | Meaning |
|---|---|
| `RATE_LIMITED` | Google kept refusing the run's addresses; run again later, or choose Residential in the proxy settings |
| `BLOCKED` | Google refused the request; same remedies |
| `NETWORK` | Google could not be reached |
| `PARSE_FAILED` | Google answered with a page this Actor does not know; please report it |

Error rows are never charged. Searches with no images at all are listed in the log and in the run summary.

### Tips and limits

- **Google shows at most about 400-600 images for one search.** To collect more, split the topic into narrower searches ("red sneakers men", "red sneakers women") or run the same search with different filters or countries.
- **Use operators to focus.** `site:unsplash.com mountains` returns images from one site only; `-stock` drops pages that mention "stock".
- **Turn off page titles for the fastest runs.** Each image then costs one request less; the file type then comes from the image URL and is missing for URLs without an extension.
- **Images are not downloaded.** You get their URLs; the originals stay on the websites that host them, and a few sites block hotlinking. The thumbnail URL always loads.
- **Licences.** The usage-rights filter is Google's and relies on the licence information pages publish. Check the licence on the source page before you reuse an image.
- **Exact sizes are not offered** because Google ignores them on this page; use "Larger than" sizes instead.
- **Hit your spending limit?** The run stops cleanly at your maximum cost per run and keeps everything it collected. Raise the limit in the run options to get more.

### FAQ

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

This Actor collects only what Google Images shows publicly, without logging in, and does not download the images themselves. The images belong to their owners and may be protected by copyright; results can also contain personal data, which laws such as the GDPR protect. Use the data for a legitimate purpose, check licences before reusing images, and ask a lawyer if you are unsure. Google and Google Images are trademarks of Google LLC; this Actor is not affiliated with or endorsed by Google.

#### Can I use it through the API or with Make, Zapier and n8n?

Yes. Every run can be started through the [Apify API](https://docs.apify.com/api/v2) and returns the dataset as JSON, CSV or Excel. Schedules, webhooks and integrations for Make, Zapier, n8n and Google Sheets are on the **Integrations** tab.

#### Can AI agents use it?

Yes. Agents connected to [Apify's MCP server](https://mcp.apify.com) can find and run this Actor as a tool, with the same per-image pricing. A call with just `{"queries": ["..."]}` works; every other field has a sensible default.

#### I use hooli/google-images-scraper. Will my integration work?

Yes. Send the same input (`queries`, `maxResultsPerQuery`) and read the same fields (`query`, `title`, `imageUrl`, `imageWidth`, `imageHeight`, `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight`, `origin`, `contentUrl`). The rows also carry the extra fields listed above.

#### Why did I get fewer images than I asked for?

Google has fewer images for that search and filter combination than your limit (it never shows more than about 600), duplicates were removed, the run reached your maximum cost per run, or it reached its timeout. The log says which, and nothing collected before that is lost.

### Related scrapers

- [Google Search Results Scraper](https://apify.com/eiv/google-search-scraper): the web, News and Videos tabs of Google, with organic results, places and top stories.
- [Pinterest Scraper](https://apify.com/eiv/pinterest-fetcher): images and pins from Pinterest, the other big place people search for pictures.
- [Website Brand Extractor](https://apify.com/eiv/website-brand-extractor-pay-per-event): logos, colors and brand assets from the websites your images come from.

### Support

Missing a field, or found a search that does not work? Open an issue on the **Issues** tab with the input you used, and it will be looked at quickly.

# Actor input Schema

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

One search per line, as you would type it into Google Images. Operators work: site:example.com, -word, "exact phrase". A Google Images URL works too and keeps its own filters, country and language. Example: golden retriever puppy

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

Stop each search after this many images. Google shows at most about 400-600 images for one search, 20 per page. You pay per image, so this is also your cost cap per search.

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

Stop the whole run after this many images, across all searches.

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

Google's size filter: Large, Medium, Icon, or larger than a minimum size (e.g. 4 MP = at least 2272 x 1704).

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

Full color, black and white, transparent background, or images dominated by one color.

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

Photos, faces, clip art, line drawings or animated GIFs.

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

Only images in this format.

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

Tall (portrait), square, wide (landscape) or panoramic images.

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

Google's licence filter: images marked with a Creative Commons licence, or with commercial and other licences. Always check the licence on the source page before reusing an image.

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

Only images Google first found in this period. Use From date / To date for a custom range.

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

Custom range start (YYYY-MM-DD): only images Google dates on or after this day. Replaces "Time" when set.

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

Custom range end (YYYY-MM-DD): only images Google dates on or before this day.

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

On: Google filters out explicit images. Off: no filtering.

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

Country whose Google Images results you want (Google's gl parameter). Default: United States.

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

Language of Google's interface (hl), which also shapes which images rank. Default: the country's main language.

## `exactQuery` (type: `boolean`):

Turn off Google's autocorrect, so a misspelled or rare word is searched as written. When it is off and Google corrects a search, each image says so in correctedQuery.

## `includePageDetails` (type: `boolean`):

Adds the title of the page each image is on and Google's file type. One small extra request per image, included in the price; turn off for the fastest runs (the file type then comes from the image URL).

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

Leave as is: when Google rate-limits, the run switches between its own address and Apify's datacenter proxy, both free. Pick Residential only if runs keep getting refused; results pages then use it after the free addresses (page titles always use the free ones). Your own proxy URLs replace the datacenter step.

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

How many searches run at the same time. Google requests are capped at 8 in flight whatever this says.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for one response before trying another address.

## Actor input object example

```json
{
  "queries": [
    "golden retriever puppy"
  ],
  "maxResultsPerQuery": 100,
  "maxItems": 10000,
  "imageSize": "any",
  "color": "any",
  "imageType": "any",
  "fileType": "any",
  "aspectRatio": "any",
  "usageRights": "any",
  "timePeriod": "any",
  "safeSearch": true,
  "exactQuery": false,
  "includePageDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 3,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

One row per image (recordType "image"), plus one uncharged row per search that could not be read (recordType "error").

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

Totals for the run: searches, images, failures, searches with no images, requests per address and why the run stopped.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("eiv/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"] }

# Run the Actor and wait for it to finish
run = client.actor("eiv/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"
  ]
}' |
apify call eiv/google-images-scraper --silent --output-dataset

```

## MCP server setup

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