# Google Images Scraper: past the 300-image limit (`alexmorain/google-images-scraper`) Actor

Scrape Google Images without a browser or SerpApi, past Google's 300-image limit per search: full-size URL, size, title, source page, a stable image ID. Filters for size, type, color and period. New-image watch.

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

## Pricing

from $0.25 / 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 does Google Images Scraper do?

**Google Images Scraper** collects the images that [Google Images](https://www.google.com/search?q=espresso+machine\&udm=2) shows for a search. It is a Google Images API alternative that needs **no browser and no SerpApi key**. For every image you get the **full-size URL**, its width and height, the thumbnail, the title, the page it appears on and a **stable image ID**, in the country and language you choose.

It returns links and metadata, not the picture files. It does not open the pages behind the images, and it does not tell you the license of an image (see the FAQ).

### Why use Google Images Scraper?

Three things get in the way of collecting Google Images at scale. This Actor handles all three.

**1. Google stops every image search at about 300 results.** Scroll as far as you like in a browser, the list ends around 350. Through plain pagination we measured the same wall (search `espresso machine`, 3 November 2026):

| Method | Google requests | Distinct images |
|---|---|---|
| Pages of the search only (Complete coverage off) | 7 | 340 |
| Complete coverage, 30 requests | 30 | 2,030 |
| Complete coverage, `bialetti moka express` (a narrow search), 24 requests | 24 | 1,355 |
| Complete coverage, `machine à café`, France, 24 requests | 24 | 1,580 |

Past the wall, the Actor reads the **related searches Google itself suggests** under your search (`commercial espresso machine`, `portable espresso machine`...), then the related searches of those. Each one returns up to 100 images, 30 to 90 of them new in our runs. Every image is returned once, and the field `variant` tells you which related search found it. Images from a related search are about the same subject, not always your exact words: for `bialetti moka express`, the related searches include `bialetti brikka` and `moka`. Keep the lines where `variant` is empty if you want only your own search.

**2. Google's pagination lies at page 5.** Google answers `start=40` with an empty page and a normal 200 status, then gives 44 to 50 new images at `start=50`. A scraper that stops at the first empty page misses them. We saw it on both passes of our local test of `espresso machine` and again in a run on the Apify platform. This Actor keeps reading after one empty page and stops only after two pages in a row without a new image.

**3. Images change and you want what is new.** The **Watch** mode remembers the images earlier runs delivered and returns only the ones you have not received. Nothing is cached on our side: every run asks Google live.

Also worth knowing:

- Schedule it on Apify, run it from the API, send results to Make, Zapier, Google Sheets or a webhook.
- 13 countries, each checked with a real request: United States, United Kingdom, Canada, Australia, Germany, France, Spain, Italy, Netherlands, India, Brazil, Mexico, Japan.
- Filters for size, type, color and time period, each checked one by one against what Google returns (see "How the filters work").
- Runs in 512 MB of memory. The measured peak was 123 MB on a 2,030-image run.

### What data can Google Images Scraper extract?

| Field | Type | Description |
|---|---|---|
| `imageId` | string | Stable ID of the image: a fingerprint of its full-size URL. The same image has the same ID in every run, use it as your key |
| `imageUrl` | string | URL of the full-size image on the site that hosts it |
| `width`, `height` | integer | Size in pixels, as Google reports it |
| `thumbnailUrl` | string | Thumbnail on Google's servers |
| `title` | string | Title Google shows for the image, usually the title of its page |
| `sourceUrl`, `sourceDomain` | string | The page where the image appears, and its domain |
| `position`, `page` | integer | Rank in the Google page that returned the image, and the page of the search |
| `query`, `variant` | string | Your search, and the related search that found the image (empty when the image comes from your own search) |
| `country`, `language` | string | Country code and interface language of the search |
| `filters` | string | The filters applied, empty without filters |
| `searchUrl`, `scrapedAt` | string | The Google request that found the image, and when |

A field Google does not show for an image is `null`.

### How to scrape Google Images

1. Open the Actor and go to the **Input** tab.
2. Type one or more **Search terms**, for example `espresso machine`. Each line is one search.
3. Pick the **Country**. It sets the Google domain and the sites Google favors.
4. Set **Max images per search** and press **Start**.
5. Download the dataset as JSON, CSV or Excel, or read it through the API.

To follow a topic, set **Watch** to *New images only*, name the monitor, and schedule a daily run.

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

You pay per event: a small amount when the run starts and an amount for each image returned. Duplicates, images below your minimum size and, in Watch mode, images already delivered are never charged. The Google proxy is included in the price.

| Event | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|
| Image (per 1,000) | $0.60 | $0.50 | $0.40 | $0.25 |
| Actor start (per GB of memory, 512 MB by default) | $0.002 | $0.002 | $0.002 | $0.002 |

At the Bronze price, 100 images cost about $0.05 and 1,000 images about $0.50. A run of 2,030 images costs about $1.02. Set a maximum charge for the run in the run options: the Actor stops when it is reached and keeps everything it already delivered.

Speed: a search for 50 images takes 1 Google request and about 5 seconds. Our 30-request run returned 2,030 images in 92 seconds.

### Input

See the **Input** tab for every option. The ones that need a word:

- **Search terms** and **Google Images URLs** can be mixed. From a URL (`udm=2` or `tbm=isch`) the Actor reads the search text, `hl`, `gl` and the size, type, color and period filters.
- **Max images per search** (100 by default) and **Max images** (1,000, across all searches) are the limits you pay by.
- **Complete coverage** (on by default) spends up to **Max requests per search** (40) Google requests per search. It only goes past the pages of your search when you ask for more images than the pages give. Off, only the pages of your own search are read, about 330 images at most. The Actor stops a search early when 5 requests in a row find fewer than 50 new images.
- **Location** is a place named the way Google names it, from the smallest to the largest: `Austin,Texas,United States`. Maximum 63 characters.
- **Minimum width** and **Minimum height** are checked on the size Google reports for each image before it is charged.

#### How the filters work

Size, type, color and period are Google's own filters, sent with the request. We did not trust them: each one was tested with a real request and its result was checked against the data (3 November 2026).

| Filter | What we measured |
|---|---|
| Size: Large | 87 images of 100 have a short side of 800 px or more, median 1,200 px |
| Size: Medium | median short side 512 px, 1 image of 100 at 800 px or more |
| Size: Icon | 50 images of 50 have a short side of 300 px or less |
| Type: Animated | 91 images of 100 are GIF files |
| Type: Line drawing | 99 images of 100 are black, white or gray; on `golden retriever`, 30 titles of 100 mention a line, outline, drawing or sketch, against 2 without the filter |
| Type: Clip art | 0 images in common with the plain search; on `golden retriever`, 15 titles of 100 say vector, illustration, clipart or cartoon, against 0 without the filter |
| Color: Black and white | 100 of 100 dominant colors are black, white or gray, against 5% without the filter |
| Color: Transparent | 28 images of 50 are PNG files, against 3 of 100 without the filter |
| Color: a color | the share of images whose dominant color is in that color family is 1.5 to 8.8 times what the plain search gives for red, orange, yellow, green, teal, blue, purple, pink and brown, and 24 to 30 times for white and black. Pink is the weakest, green gives only 25 images of 100 in the green family |
| Time period | Day and Week: 100 images of 100 carry a date (hours for Day, hours to days for Week), against none without the filter. For `best laptops 2021`, the titles that say 2021 go from 73 of 100 to 26 for the past year and 5 for the past month |

Two Google filters are not offered because they did not filter. **Photo** returned the same images as the plain search (85 of 100 in common, and 76 of 100 titles still said "cartoon" on `cartoon cat`, against 85 without the filter). **Face** returned landscapes for `mountain landscape`. The **license** filter (Creative Commons) is ignored by Google without a browser: 97 images of 100 were the same as the plain search. If a start URL carries a license filter, the Actor ignores it and says so in the log.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A shortened item:

```json
{
  "imageId": "6276e81017db7f7a",
  "imageUrl": "https://www.bialetti.com/media/catalog/product/m/o/moka-express-mousehover_1_1.jpg",
  "width": 1200,
  "height": 1200,
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcExample&s=10",
  "title": "Iconic Moka Pot Italian Coffee & Stovetop Espresso Maker",
  "sourceUrl": "https://www.bialetti.com/us_en/moka-pot-3-cup-6-cup-italian-stovetop-1.html",
  "sourceDomain": "www.bialetti.com",
  "position": 1,
  "page": 1,
  "query": "bialetti moka express",
  "variant": null,
  "country": "us",
  "language": "en",
  "filters": null,
  "searchUrl": "http://www.google.com/search?q=bialetti+moka+express&udm=2&hl=en&gl=us",
  "scrapedAt": "2026-11-03T12:00:00Z"
}
```

Each run also writes a `SUMMARY` record to the key-value store. For every search it gives the Google requests made, pages read, empty and failed ones, distinct images found, images returned, images dropped by your minimum size, related searches found, the yield of every request (`curve`: kind of query, page, images on the page, new images, matching images) and why the search stopped (`max-items`, `max-items-query`, `max-requests`, `low-yield`, `exhausted`, `no-results`, `blocked`).

#### Use it from Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/google-images-scraper").call(run_input={
    "queries": ["espresso machine"],
    "country": "us",
    "maxItemsPerQuery": 1000,
    "imageSize": "large",
    "minWidth": 1200,
})
for image in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(image["width"], image["height"], image["imageUrl"])
```

#### Use it from JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('alexmorain/google-images-scraper').call({
    queries: ['espresso machine'],
    country: 'us',
    maxItemsPerQuery: 1000,
    timePeriod: 'week',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].imageUrl);
```

#### Use it from cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~google-images-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["espresso machine"], "maxItemsPerQuery": 100}'
```

### Tips

- **Ask for the number of images you need.** The Actor stops as soon as it has them. Raise **Max images per search** past 330 to make it read the related searches.
- **Raise Max requests per search** (up to 1,000) for a broad search. In our runs a broad search still brought 35 to 80 new images per request at the 30th request. The `low-yield` stop reason in the summary tells you when a search ran dry.
- **Watch is a feed, not a snapshot.** Google does not show the same set twice: on `bialetti moka express`, 78 of the 100 images of a first run came back in the first two pages of a second run, and all 78 were recognized by their ID. An image that did not show up in a run is not removed from the memory.
- **Daily feed.** Watch, a monitor name and a webhook URL. The webhook receives a short JSON summary when at least one image was returned.
- **One run, several searches.** Several searches share the **Max images** limit.

### FAQ, disclaimers, and support

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

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. Check Google's terms for your use case as well. The images belong to the sites that host them: this Actor gives you links, not a right to reuse the pictures.

#### How many images can I scrape from Google Images?

One search gives about 330 images through the pages Google offers. With Complete coverage the Actor goes past that through related searches: 1,355 to 2,030 distinct images in 24 to 30 requests on the searches we measured. How far it goes depends on the topic and on your **Max requests per search**.

#### Why does Google Images stop at 300 images?

Google caps the list of each image search at about 300 to 350 results, in a browser as well as in a scraper. Related searches are different searches, so they start a new list.

#### Can I filter Google Images by license or Creative Commons?

No. Google applies that filter only in a browser session, and the same request without a browser returns the unfiltered results (97 images of 100 identical in our test). Filter by `sourceDomain` after the run if you want only sites such as Wikimedia, Unsplash or Pexels, and check the license on the page.

#### Why does a run return fewer images than Max images?

Google had no more distinct images for the search, your minimum size dropped many of them, or the budget of requests ran out. Read the `endReason` of each search in the `SUMMARY` record.

#### Why are some images not about my exact search?

Past 330 images they come from related searches Google suggests. The `variant` field names the related search. Keep only the lines where `variant` is empty to stay on your own search.

#### Can I download the image files?

No, the Actor returns the URL of each image. Download them with the tool of your choice. Some hosts block direct downloads or move the file, so a link can stop working over time.

#### Is there a Google Images API?

This Actor returns what the Google Images page shows, as JSON, through the Apify API: run it, then read the dataset.

#### Why did the run fail?

A run fails when the input is invalid, or when Google refused every request of the run. Nothing is charged in that case. Try again in a few minutes.

#### Can I call it from code?

Yes, see the **API** tab for the endpoints and client libraries. Something wrong or missing? Open a ticket in the **Issues** tab and it will be fixed.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Google Images Scraper page](https://alexis.morain.fr/en/scrapers/google-images-scraper/) of my site. The [SEO and search engines family page](https://alexis.morain.fr/en/scrapers/families/seo/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

One image search per line, as you would type it in Google Images: <code>espresso machine</code>, <code>golden retriever puppy</code>. Each line is one search.

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

Which Google to ask: it sets the domain (google.com, google.de...) and the country of the sites Google favors. Without this, Google would answer for the country of the proxy's IP address.

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

Interface language of Google, a two-letter code such as <code>en</code>, <code>de</code>, <code>fr</code>. Empty uses the main language of the country.

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

Optional. A place more precise than the country, written as Google names it, from the smallest to the largest: <code>Austin,Texas,United States</code>, <code>Lyon,Auvergne-Rhone-Alpes,France</code>. Maximum 63 characters. Leave empty to use the country.

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

Optional. Google Images search URLs, such as <code>https://www.google.com/search?q=espresso+machine\&udm=2</code> (or <code>tbm=isch</code>). The search text, <code>hl</code>, <code>gl</code> and the size, type, color and period filters (<code>tbs</code>) are read from the URL. A filter set in this form wins over the one in the URL. The license filter is not supported: Google ignores it without a browser.

## `maxItemsPerQuery` (type: `integer`):

Images returned for each search. One Google page gives 50 to 100 images and the pages of one search stop at about 330. Complete coverage goes further, up to the number of Google requests allowed below.

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

Total images returned by the run, across all searches.

## `completeCoverage` (type: `boolean`):

On: when the pages of your search do not give enough images, read the related searches Google suggests (and theirs) until nothing new comes back, up to <b>Max requests per search</b>. Off: only the pages of your own search (about 330 images at most). Images found through a related search are marked in <code>variant</code> and are about the same subject, not always the exact words of your search.

## `maxRequestsPerQuery` (type: `integer`):

Budget of Google requests for each search (each returns up to 100 images). The Actor stops earlier when 5 requests in a row find fewer than 50 new images.

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

Google requests in flight at once, 1 to 16.

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

Google's size filter: <b>Large</b> (the usual 800 pixels and more), <b>Medium</b> or <b>Icon</b> (small, up to about 300 pixels). Applied by Google; for an exact minimum use the two fields below.

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

Google's type filter: <b>Clip art</b>, <b>Line drawing</b> or <b>Animated</b> (GIF). The photo and face filters are not offered: Google does not apply them without a browser.

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

Google's color filter: black and white (<code>gray</code>), <code>transparent</code> background, or one dominant color.

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

Only images Google dated within the last day, week, month or year.

## `minWidth` (type: `integer`):

Keep images at least this wide. Checked on the size Google reports for each image: a smaller one is dropped, not charged.

## `minHeight` (type: `integer`):

Keep images at least this tall. Checked like the minimum width.

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

Remembers the images returned by earlier runs. <b>New images only</b> returns only images not delivered before, and charges only those. The first run returns everything that matches. Schedule it daily for a feed that never repeats. The set Google shows changes from one pass to the next: the watch is a feed of images not seen yet, not a complete state.

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

Without a name, the memory belongs to each search as typed. With a name, every run using that name shares it. The memory lives in your key-value store <code>google-images-monitor</code>.

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

If set, the Actor POSTs a small JSON summary to this URL at the end of the run, <b>only when at least one image was returned</b>: <code>actor</code>, <code>runId</code>, <code>datasetId</code>, <code>images</code>, <code>monitorMode</code> and one line per search. Use the final URL: a redirect is not followed, except a 307 or 308. An unreachable webhook is logged and never fails the run. Stored encrypted.

## Actor input object example

```json
{
  "queries": [
    "espresso machine"
  ],
  "country": "us",
  "maxItemsPerQuery": 50,
  "maxItems": 1000,
  "completeCoverage": true,
  "maxRequestsPerQuery": 40,
  "maxConcurrency": 10,
  "imageSize": "any",
  "imageType": "any",
  "color": "any",
  "timePeriod": "any",
  "monitorMode": "off"
}
```

# Actor output Schema

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

All images in the default dataset.

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

For each search: Google requests, pages, empty and failed ones, distinct images found, images returned, images dropped by your minimum size, related searches found, the yield of each request and why the search 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": [
        "espresso machine"
    ],
    "maxItemsPerQuery": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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": ["espresso machine"],
    "maxItemsPerQuery": 50,
}

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

```

## MCP server setup

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