# Google Images Scraper & API - $0.10 per 1,000 Images (`santhej/google-images-scraper`) Actor

Scrape Google Images for any keyword: the direct image file URL on the publisher’s own server, title, alt text, publisher name, source page and rank. Up to 300 images per query, 18 countries, no expiring thumbnails. Clean JSON/CSV for datasets, ecommerce and brand monitoring.

- **URL**: https://apify.com/santhej/google-images-scraper.md
- **Developed by:** [Santhej Kallada](https://apify.com/santhej) (community)
- **Categories:** SEO tools, Marketing
- **Features:** Limited permissions
- **Stats:** 26 total users, 6 monthly users, 83.2% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.08 / 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.
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 — Image Search Results & Sources API

**Scrape Google Images for any keyword: every image's direct URL, title, source page and rank — up to 300 per query, as clean JSON or CSV, at $0.10 per 1,000 images.**

Image search is its own battlefield. For product searches, a large share of clicks starts in the image grid, and which photos rank there decides whose product gets seen. For brands, the image SERP shows where your visuals travel; for data teams, it is the fastest map from a keyword to real-world pictures and the pages that host them.

### What does Google Images Scraper do?

This Actor runs a Google Images search for each keyword and returns one row per image, in Google's ranking order: the direct image URL on the publisher's own server, its title and alt text, the publisher name, and the page it was found on with its domain. No browser to babysit, no CAPTCHAs, no proxies to configure.

### What you get per image

| Field | What it tells you |
|---|---|
| `position` | The image's rank in the results (1-based) |
| `title` | The image's title |
| `alt` | The image's alt text as Google carries it |
| `source_name` | The publisher or brand Google shows under the image |
| `image_url` | **Direct URL of the image file on the publisher's own server** — not an expiring Google thumbnail |
| `source_page_url` | The page the image was found on |
| `source_domain` | That page's domain — who owns the visual SERP |
| `google_url` | Google's own thumbnail of the image (`encrypted-tbn0.gstatic.com`) — handy for quick previews, but a Google cache link that can expire |
| `country` / `language` / `checked_at` | Exactly which search this row came from, so results stay reproducible |

Every `image_url` points at the publisher's original file, so it keeps working after the run. Actors that return only `encrypted-tbn0.gstatic.com` thumbnails hand you links that rot — here the thumbnail is an extra (`google_url`), never the only link.

A run summary is written to the key-value store with total images found, the average per keyword and any per-keyword errors.

### Use cases

- **Visual rank tracking** — does your product photo rank for "standing desk", and at what position?
- **Ecommerce competitor monitoring** — whose product imagery owns the grid for your money keywords.
- **Brand monitoring** — find where your visuals and packshots appear across the web.
- **Dataset assembly** — keyword-labelled image URLs with their source pages, ready for ML pipelines and licensing review.
- **Content sourcing** — see which pages publish the imagery Google trusts on a topic.
- **Agent workflows** — clean JSON for an LLM agent that needs live image-search context.

### How to use

1. Add one or more **Keywords** — each one is a separate Google Images search.
2. Pick the **Country** whose image results you want (18 markets) and, optionally, a **Language**.
3. Set **Max images per keyword** (10–300).
4. Click **Start**, then export the dataset as JSON, CSV or Excel, or fetch it through the Apify API.

#### Example input

```json
{
  "keywords": ["standing desk", "ergonomic office chair"],
  "countryCode": "us",
  "languageCode": "en",
  "maxImagesPerKeyword": 100
}
```

#### Input configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | array of strings | — (required) | Image searches to run, up to 200 per run. Duplicates are removed. |
| `maxImagesPerKeyword` | integer | `100` | Images to return per keyword, 10–300. |
| `countryCode` | string | `us` | One of `us`, `gb`, `ca`, `au`, `in`, `de`, `fr`, `es`, `it`, `nl`, `br`, `mx`, `jp`, `sg`, `ae`, `za`, `ie`, `nz`. |
| `languageCode` | string | `en` | Two-letter interface language (ISO 639-1), e.g. `en`, `de`, `es`. |

#### Example output

A real row from a `standing desk` search in the United States:

```json
{
  "record_type": "image",
  "keyword": "standing desk",
  "position": 2,
  "title": "VariDesk Pro Plus 36 in. Height-Adjustable Standing Desk Converter (Espresso Wood)",
  "alt": "VariDesk Pro Plus 36 in. Height-Adjustable Standing Desk Converter (Espresso Wood)",
  "source_name": "Varidesk",
  "image_url": "https://www.vari.com/dw/image/v2/BDFT_PRD/on/demandware.static/-/Sites-vari-master-catalog/default/dwe7f95fef/images/large/DC-PP36/42431-black/vari-desktop-converter_42431_black_raised.jpg?sw=800&sh=800",
  "source_page_url": "https://www.vari.com/sit-stand-converter-varidesk-pro-plus-36/DC-PP36.html",
  "source_domain": "vari.com",
  "google_url": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQ-bhXG2hcKbwXBTgsKdT7PYosO-5V3TxYA_xqkSiAxmg&s=10",
  "country": "us",
  "language": "en",
  "checked_at": "2026-09-23T03:08:41.293Z"
}
```

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

Pay per event. No monthly fee, no setup fee.

| Event | Price |
|---|---|
| Actor start | $0.004 per run |
| Image result | **$0.0001 per image — $0.10 per 1,000** |

- One keyword at 100 images: $0.004 + 100 × $0.0001 = **$0.014**.
- Three keywords at 50 images each (150 rows): **$0.019**.
- Ten keywords at 100 images each (1,000 rows): **$0.104**.

You pay per image actually returned. Every keyword is one Google search with a fixed cost of its own, so each keyword is billed at least about **$0.0063** — the price of ~63 images. Above roughly 60 images per keyword that minimum never applies; below it, lowering **Max images per keyword** stops lowering the price, and the run summary shows any minimum-charge units as `minimum_charge_units_added`.

### FAQ

**Do I need an API key?** No. Everything is handled for you — just add keywords and run.

**Why did a keyword return fewer images than I asked for?** Google returns what it has. Niche queries can have thinner grids; you are only charged for the images actually returned.

**Are these full-size images or thumbnails?** `image_url` points at the image file the source site hosts, where Google exposes it. Base64 thumbnail blobs are deliberately excluded so your exports stay small and clean.

**Can it download the image files?** The Actor returns direct URLs, which any downloader, script or n8n workflow can fetch. Keeping files out of the dataset keeps runs fast and cheap.

**Which countries work?** 18 countries are selectable, with the United States as the default. Image results are localized per market.

**Is the ranking order preserved?** Yes — `position` is the order Google returned the images in, which is the order searchers see.

**Can I export it?** Yes — JSON, CSV, Excel, or straight into n8n, Make or Zapier via the Apify API.

### More Google SERP intelligence

- [People Also Ask Scraper](https://apify.com/santhej/people-also-ask-scraper) — every PAA question with its answer and source page, per keyword.
- [Google AI Overview Tracker](https://apify.com/santhej/google-ai-overview-tracker) — does Google's AI Overview answer your keywords, and does it cite you?
- [Google AI Mode Tracker](https://apify.com/santhej/google-ai-mode-tracker) — the same visibility check for Google's conversational AI tab.
- [Website Traffic Intel](https://apify.com/santhej/website-traffic-intel) — traffic estimates and engagement metrics for any domain list.

***

*Tags: google images scraper, image search api, google image search results, scrape google images, image serp api, image seo, visual seo, image rank tracker, ecommerce image monitoring, brand image monitoring, image dataset builder, reverse sourcing, product images, serp api, google scraper*

# Actor input Schema

## `keywords` (type: `array`):

The image searches to run. One row of output per image found, in Google's ranking order.

## `maxImagesPerKeyword` (type: `integer`):

How many images to return per keyword (10-300). You are billed per image actually returned, and the search is sized to your request so a small run stays cheap.

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

Country to search from. Image results are localized, so pick the market you care about.

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

Two-letter interface language code (ISO 639-1), e.g. 'en', 'de', 'es'.

## Actor input object example

```json
{
  "keywords": [
    "standing desk"
  ],
  "maxImagesPerKeyword": 30,
  "countryCode": "us",
  "languageCode": "en"
}
```

# Actor output Schema

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

One row per image result.

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

Keywords checked, images returned, errors and the billing breakdown for the run.

# 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 = {
    "keywords": [
        "standing desk"
    ],
    "maxImagesPerKeyword": 30,
    "countryCode": "us",
    "languageCode": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("santhej/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 = {
    "keywords": ["standing desk"],
    "maxImagesPerKeyword": 30,
    "countryCode": "us",
    "languageCode": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("santhej/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 '{
  "keywords": [
    "standing desk"
  ],
  "maxImagesPerKeyword": 30,
  "countryCode": "us",
  "languageCode": "en"
}' |
apify call santhej/google-images-scraper --silent --output-dataset

```

## MCP server setup

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