# Google Images Scraper - Google Image Search API (`s-r/google-images`) Actor

Turn keywords into Google Images results: rank, original image URL with width and height, thumbnail, page title, landing page and source site, per country and language, with size, color, type and usage-rights filters. For SEO teams, e-commerce, dataset builders and brand monitoring.

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

## Pricing

$1.00 / 1,000 image results

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

Google Images Scraper turns search queries into structured image search results. Export original image URLs, dimensions, thumbnails, page titles and source websites for SEO research, product discovery, visual datasets and brand monitoring, without writing your own scraper.

Each row represents one image returned by Google Images for one query. Results keep their search order and include the landing page where the image appears. You can search several terms in one run and choose a country, interface language and image filters for size, color, type, usage rights and SafeSearch. The Actor returns URLs and metadata; it does not download image files into the dataset.

### How to scrape Google Images with Google Images Scraper

1. Enter one or more search terms in **Search queries**, for example `red sneakers`.
2. Pick the market with **Country** and the interface language with **Language**.
3. Set **Max results** per query. One Google Images page holds up to 100 images.
4. Optionally add filters: size, color, type, usage rights or SafeSearch.
5. Start the run and download the dataset as JSON, CSV, Excel or another supported format, or read it through the Apify API.

### Google Images Scraper input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array of strings | (required) | Search terms, up to 100 per run. Newline-separated text is also accepted. |
| `country` | string | `us` | Two-letter market code, such as `us`, `gb` or `nl`. Affects ranking. |
| `language` | string | `en` | Interface language, two letters with an optional country suffix. |
| `maxResults` | integer | `100` | Maximum images per query, 1 to 1000. |
| `safeSearch` | boolean | `false` | Forwards Google's SafeSearch setting. |
| `size` | string | `any` | `large`, `medium`, `icon` or `4mp`. |
| `color` | string | `any` | `color`, `grayscale`, `transparent`, or a single color such as `red` or `blue`. |
| `type` | string | `any` | `photo`, `face`, `clipart`, `lineart` or `animated`. |
| `usageRights` | string | `any` | `creative_commons` or `commercial`. |

Empty lines and surrounding whitespace in `queries` are removed. Commas are preserved because they can be part of a search term. Repeated terms are processed as separate input positions, so their results remain available separately.

`maxResults` is a maximum, rather than a promise of that many images: Google can exhaust the available results before reaching your requested number. A query that returns fewer images does not receive invented records to fill the limit.

For example, the following input searches the US market for the term used in the recorded example below:

```json
{
  "queries": ["red sneakers"],
  "country": "us",
  "language": "en",
  "maxResults": 100
}
```

The language of an individual page title still depends on the source website, whatever interface language you choose.

#### Image filters

`4mp` requests Google's approximately four-megapixel threshold. The output dimensions let you apply your own exact pixel requirement after collecting the results. The single-color options are red, orange, yellow, green, teal, blue, purple, pink, white, gray, black and brown. Multiple filters can be combined in the same search.

`safeSearch: true` forwards Google's SafeSearch setting. It does not guarantee that every returned image meets a particular content policy. `usageRights` forwards Google's corresponding search filter. The filter describes a search selection; licensing information belongs to the source page and the image owner.

### Google Images Scraper output

This is the first row of a real run for `red sneakers` in the US market with the input above (100 rows in total):

```json
{
  "docid": "78ZpzH1qA5T59M",
  "title": "Red Sneakers Are The Flamboyant Trend of 2025 | Vogue Arabia",
  "image_url": "https://media.voguearabia.com/photos/6880b2cf0046fcdee6b38dd1/1:1/w_1440,h_1440,c_limit/sneakers%20rosse%20Instagram%20@tia_dewitt%20.jpg",
  "image_width": 1440,
  "image_height": 1440,
  "thumbnail_url": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTXQpSJkdhskimyzU_ulM_pwdRwQAMrfMZAazznotwJzw&s=10",
  "thumbnail_width": 554,
  "thumbnail_height": 554,
  "url": "https://www.voguearabia.com/article/red-sneakers-are-the-flamboyant-trend-of-2025",
  "domain": "voguearabia.com",
  "source_name": "Vogue Arabia",
  "file_size": "369KB",
  "dominant_color": "rgb(16,16,16)",
  "query": "red sneakers",
  "position": 1,
  "source": "google-images",
  "engine": "google_images",
  "country": "us",
  "language": "en",
  "fetched_at": "2026-10-05T00:07:02.956Z"
}
```

#### Dataset fields

`query` and `position` identify the search and the rank. `position` starts at one for each query and continues across its result pages. Duplicate Google image document IDs within the same query are removed before positions are assigned. The same image can still appear for different queries, which preserves its relevance to each search term.

`title` is the source page title. `url` is its landing page, `domain` is the hostname without the leading `www.`, and `source_name` is the website name displayed by Google. `image_url` points to the original image. `image_width` and `image_height` contain its reported pixel dimensions. `thumbnail_url`, `thumbnail_width` and `thumbnail_height` describe Google's preview image.

Additional fields include `docid`, Google's document identifier, `file_size`, the displayed file size label, and `dominant_color`, the reported RGB color. File size and color can be null when Google does not provide them. Each row also includes `country`, `language`, `fetched_at`, `source` and `engine`, so exports retain their search context and collection time.

The `OUTPUT` record in the key-value store contains run information. If a query fails, its English error message is recorded with that query; successfully collected results from other queries are still delivered.

### Use cases

- **Image SEO and rank tracking.** See which pages and domains own the image results for your keywords, track `position` over time and compare markets by changing `country`.
- **E-commerce and product discovery.** Find which shops and marketplaces show their product photos for a product term, and how large those photos are.
- **Brand monitoring.** Search your brand or product names and see which websites publish images of them, with the landing page for each image.
- **Visual datasets and AI training data collection.** Collect original image URLs with dimensions and source pages for a list of concepts, then filter on size, type or usage rights before you download anything.
- **Content research.** Gather reference images and their sources for articles, mood boards or competitor reviews.

### Google Images Scraper compared with other options

- **Google's own search APIs.** Google's programmable search API searches a configured search engine and returns a small number of results per request. Google Images Scraper reads the regular Google Images results tab for your market, up to 100 images per page.
- **Python scripts and browser automation.** A self-built Google image scraper in Python needs a browser, maintenance whenever the page changes, and its own handling of empty and failed pages. Here you send a query and receive clean rows.
- **Other Google image search APIs.** SERP API services often charge per search request. This Actor charges per image actually delivered, and empty searches cost nothing.
- **Reverse image search.** To search with a picture instead of words, use our Google Lens Actor. Google Images Scraper is the text-to-image counterpart: keyword in, image results out.

### Pricing

The billable unit is one image result delivered to the dataset. The `image` event counts those delivered rows. Empty searches produce zero image events, and there is no separate start fee. The current event price is shown in the Actor's Pricing tab. A run of three queries with `maxResults: 100` that returns 100 images for each query creates 300 image events; a query that only has 40 images creates 40.

The result limit controls the maximum number of images requested per query, while Apify's run charge limit controls spending. Duplicate records removed within a query do not create extra image events.

Non-paying users can receive up to ten image results in total per run, including runs with several queries. Paying users can request the full configured volume.

### Pagination and partial results

The Actor automatically collects further result pages until each query reaches its maximum or Google reports that no more images are available. You do not need to provide a cursor for an ordinary Apify run. A large request may be collected in several steps, with the original search options preserved between them.

If a query cannot complete, already collected images remain available and the run reports the affected query. An empty first page is reported as no results. A response that cannot be interpreted as a valid image page is reported as a source failure, rather than silently being treated as an empty search.

### FAQ

#### Can I use Google Images Scraper as a Google image search API?

Yes. Start the Actor through the Apify API with the same JSON input and read the dataset items when the run finishes, or use the synchronous run endpoint to receive the rows in one call. Client libraries are available for JavaScript and Python, and the Actor works with Apify integrations and schedules.

#### Is there a free Google image search API option?

Users on the free Apify plan can run the Actor and receive up to ten image results per run. That is enough to test the output format and filters before you collect at scale.

#### Does the Actor download the original images?

It exports original image URLs and dimensions. Download image files separately if your workflow needs the actual files. The image address and the landing page address are both available in each row.

#### Why do I receive fewer images than maxResults?

The limit is an upper bound. Google can return fewer matching images, especially when several filters are combined. The Actor stops when the available result pages are exhausted. A partial source failure is reported separately.

#### Are result positions comparable across countries?

Positions describe the order returned for the selected query and market at collection time. Changing the country can change both ranking and available results. Keep the query, country and collection timestamp together when comparing exports.

#### Can the same image appear more than once?

Duplicate document IDs are removed within a query. An image matching two different search queries can appear once for each query, and repeated input queries are processed separately.

#### Can I use the images I find?

The Actor reports what Google shows; it does not grant any rights to the images. The `usageRights` filter narrows the search to images Google labels with matching licences, but check the licence on the source page before reusing an image.

# Actor input Schema

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

Search queries as an array or newline-separated text. The limit applies to each query.

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

Two-letter Google market code (gl), used for ranking.

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

Google interface language (hl), with an optional country suffix.

## `maxResults` (type: `integer`):

Maximum unique image results per query. Google can return fewer results.

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

Forward SafeSearch to Google. This does not guarantee that every image is suitable.

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

Google image color filter.

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

Google image type filter.

## `size` (type: `string`):

Google image size filter. 4mp requests images larger than approximately four megapixels.

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

Google usage rights filter; verify licensing on each source page before reuse.

## `cursor` (type: `string`):

Signed continuation token returned by a previous request. Repeat the same search options.

## Actor input object example

```json
{
  "queries": [
    "red sneakers"
  ],
  "country": "us",
  "language": "en",
  "maxResults": 100,
  "safeSearch": false,
  "color": "any",
  "type": "any",
  "size": "any",
  "usageRights": "any"
}
```

# Actor output Schema

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

One row per image result.

## `output` (type: `string`):

Counts, status and free tier information.

## `errors` (type: `string`):

Query errors when present.

# 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": [
        "red sneakers"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/google-images").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": ["red sneakers"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/google-images"
        }
    }
}
```

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/0v2HNhjc3tDfWTASf/builds/Q4ddQZtP7Thfg0Yk3/openapi.json