# Google Images Scraper (`mina_safwat/google-images-scraper`) Actor

Scrapes Google Images results for any search: full-size image URL, width and height, thumbnail, title, source page and site name, 100 images per request, with size, color, type, time and license filters.

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

## Pricing

$1.00 / 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

### What does Google Images Scraper do?

**Google Images Scraper** collects **Google Images search results** for any
search words: the **full-size image URL with its width and height**, the
**thumbnail**, the image **title**, the **source page** it appears on, the
**site name and domain**, the **file size** and the image's **dominant color**.
Type search words or paste a Google Images results link (google.com,
images.google.com or a country domain such as google.de), and get one clean row
per image. The first Google request brings back **about 100 images**.

Try it with the prefilled search: open the Actor, click **Start**, and 50
golden retriever puppy images arrive within a minute. Because it runs on the
Apify platform, you also get API access, scheduled runs, integrations (Google
Sheets, Make, Zapier, webhooks), run monitoring and Apify Proxy built in, so
there is nothing to set up to get answers from
[Google Images](https://images.google.com).

### Why scrape Google Images?

- **Dataset building for AI and computer vision**: collect hundreds of
  labelled image URLs per keyword, with sizes, for training or evaluation sets.
- **Product and catalog enrichment**: find pictures for product names, places
  or people's public work, and filter by size, type or transparent background.
- **SEO and brand monitoring**: see which sites rank in Google Images for your
  keywords, and where your own images appear.
- **Content research**: find Creative Commons images, clip art, line drawings
  or GIFs for a topic, with the page to check the license on.
- **Market and trend research**: compare what Google shows for the same search
  in different countries and languages.

### How to scrape Google Images

1. Type your search words into **Search words or Google Images links**, one
   search per line (for example `golden retriever puppy`).
2. Or search on [Google Images](https://images.google.com), set filters in
   Tools, and paste the address bar link instead. Its filters, country,
   language and SafeSearch are used as they are.
3. Set **Max images per search** (100 by default).
4. Optionally pick a **Country**, **Language**, **SafeSearch** and filters for
   **Size**, **Color**, **Type**, **Time** and **Usage rights**.
5. Click **Start**, then download the images list when the run finishes.

### Input

Everything is set on the Input tab. In JSON, the input looks like this:

```json
{
    "queries": [
        "golden retriever puppy",
        "https://www.google.com/search?q=cat&udm=2&tbs=ic:trans"
    ],
    "maxImagesPerQuery": 100,
    "countryCode": "us",
    "languageCode": "en",
    "safeSearch": false,
    "imageSize": "large",
    "imageColor": "any",
    "imageType": "photo",
    "timePeriod": "any",
    "usageRights": "any"
}
```

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `queries` | array of strings | (required) | Search words, or Google Images result links (with or without `https://`). API callers can also send `{"url": "..."}` objects. |
| `maxImagesPerQuery` | integer | 100 | Images to save per search, 10 to 1,000. |
| `countryCode` | string | `us` | Two-letter country whose results you want (Google's `gl`). Empty lets Google decide. |
| `languageCode` | string | `en` | Interface language (Google's `hl`), such as `de` or `pt-BR`. |
| `safeSearch` | boolean | `false` | Filters explicit images out. |
| `imageSize` | string | `any` | `large`, `medium` or `icon`. |
| `imageColor` | string | `any` | `color`, `grayscale`, `transparent`, or a color: `red`, `orange`, `yellow`, `green`, `teal`, `blue`, `purple`, `pink`, `white`, `gray`, `black`, `brown`. |
| `imageType` | string | `any` | `photo`, `clipart`, `lineart` or `animated` (GIFs). |
| `timePeriod` | string | `any` | `day`, `week`, `month` or `year`. |
| `usageRights` | string | `any` | `creativeCommons` or `commercial` (commercial and other licenses). |

A pasted link keeps its own filters, country, language and SafeSearch. The
input settings fill in only what the link leaves out.

### Output

One row per image, in Google's order. A real row from the prefilled search:

```json
{
    "query": "golden retriever puppy",
    "position": 1,
    "imageId": "eYoKU9jW-eRT6M",
    "title": "Golden Retriever: Pros, Cons & Diet Guide | Ollie",
    "imageUrl": "https://blog.ollie.com/wp-content/uploads/250506_Livingroom_SHOT-10_0173_FR-scaled.jpg",
    "imageWidth": 2560,
    "imageHeight": 1707,
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSe1mLcW_M8xRI0J5UcnG6soPw9kd8XQOgz7Y4sOLFZoA&s=10",
    "thumbnailWidth": 678,
    "thumbnailHeight": 452,
    "sourceUrl": "https://blog.ollie.com/breed-deets-golden-retriever/",
    "sourceDomain": "blog.ollie.com",
    "sourceName": "Ollie Blog",
    "fileSize": "522KB",
    "dominantColor": "#597c79",
    "searchUrl": "https://www.google.com/search?q=golden+retriever+puppy&udm=2&hl=en&gl=us&safe=off",
    "scrapedAt": "2026-10-20T08:02:57.430839+00:00"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or
Excel, or read it through the Apify API.

### Data fields

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | The search words the image was found for. |
| `position` | integer | Rank of the image in the results for that search, from 1. |
| `imageId` | string | Google's id of the image result. |
| `title` | string | Title Google shows under the image (usually the source page's title). |
| `imageUrl` | string | Direct link to the full-size image on the source site. |
| `imageWidth`, `imageHeight` | integer | Size of the full-size image in pixels. |
| `thumbnailUrl` | string | Google's thumbnail of the image. |
| `thumbnailWidth`, `thumbnailHeight` | integer | Size of the thumbnail in pixels. |
| `sourceUrl` | string | The page the image appears on. |
| `sourceDomain` | string | Host name of that page, such as `www.akc.org`. |
| `sourceName` | string | Site name Google shows, such as `American Kennel Club`. |
| `fileSize` | string | File size of the full image as Google shows it, such as `190KB` or `2.5MB`. |
| `dominantColor` | string | Main color of the image as a hex code, such as `#b0a06a`. |
| `searchUrl` | string | Google Images link for the search, to open it yourself. |
| `scrapedAt` | string | When the row was saved (ISO 8601, UTC). |

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

You pay per image saved; see the **Pricing** tab for the exact price. Searches
that return nothing and entries that are not searches are never charged. The first
Google request brings back about 100 images and each later one adds roughly
50 to 100 new ones, so the platform usage of a run stays small: a run of 750 images across three searches used under $0.03 of
platform resources. The Actor stops by itself when a run reaches the maximum
cost you set for it.

### Tips for scraping Google Images

- **How many images can I get?** Google ends most searches after 200 to 500
  images. Asking for 1,000 returns everything Google has for the search.
- **Use several close searches** (`golden retriever puppy`, `golden retriever
  puppy playing`) to collect more images on one topic.
- **Filters narrow the results Google returns**, they do not post-filter
  them: a `large` search returns large images in Google's own ranking.
- **Paste links for mixed filters**: each link keeps its own filters, so one
  run can collect transparent PNGs for one search and photos for another.
- **Duplicates are removed** within each search, so `position` counts unique
  images. Later pages partly repeat earlier ones, so they add fewer new images
  than the first.
- **Usage-rights links work too**: a pasted link with Google's `il:cl` or
  `il:ol` filter is sent as `sur:cl` / `sur:ol`, the form that changes the
  results.
- **Each search page takes from a few seconds to about a minute**; several
  searches are read at the same time.

### FAQ, disclaimers, and support

**Is it legal to scrape Google Images?** The Actor reads only the public
results Google shows to anyone without logging in. Images themselves are
usually copyrighted by their owners: the Actor gives you links, and before
reusing an image you should check its license on the source page. The usage
rights filter relies on license details site owners publish, which Google does
not verify. Results may include images of people, so handle personal data
according to the laws that apply to you, such as GDPR. Web data scraping is
legal in many cases, but if you are unsure, consult a lawyer.

**Why did a search give nothing?** Google had no images for it (common with
very narrow filters). It is listed in the `FAILED_INPUTS` record of the run's
key-value store with the reason, and nothing is charged for it.

**Why does an image link not open?** `imageUrl` points to the image on the
source site, which can remove it or block direct links. `thumbnailUrl` is
served by Google and keeps working longer.

**Can I search reverse images or Google Lens?** No, only searches by words or
Google Images result links.

Found a bug or need another field? Open an issue on the **Issues** tab and it
will be looked at. Need a custom scraper or a different output format? Get in
touch through the Issues tab too.

# Actor input Schema

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

One search per line. Type words as you would in Google Images (for example golden retriever puppy), or paste the address of a Google Images results page: its search words and any filters, country, language and SafeSearch in the link are used as they are. Entries that are not searches are listed in the FAILED_INPUTS record.

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

Stops after this many images for each search (10 to 1,000). Google shows about 100 images on the first page, fewer new ones on later pages, and stops after several hundred for most searches, so very high numbers return everything Google has.

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

Two-letter country code whose Google results you want (Google's gl parameter), for example us, gb, de or eg. Leave empty to let Google decide.

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

Interface language code (Google's hl parameter), for example en, de, fr or pt-BR. It changes the language of titles Google writes itself and slightly shifts the ranking.

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

Turn on to filter explicit images out of the results.

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

Only images of this size.

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

Only images in these colors, or with a transparent background.

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

Only images of this type.

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

Only images Google found within this period.

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

Only images with license details of this kind. Always check the license on the source page before reusing an image.

## Actor input object example

```json
{
  "queries": [
    "golden retriever puppy"
  ],
  "maxImagesPerQuery": 50,
  "countryCode": "us",
  "languageCode": "en",
  "safeSearch": false,
  "imageSize": "any",
  "imageColor": "any",
  "imageType": "any",
  "timePeriod": "any",
  "usageRights": "any"
}
```

# Actor output Schema

## `dataset` (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"
    ],
    "maxImagesPerQuery": 50
};

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

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

```

## MCP server setup

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