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

Scrape Google Images search results: full-size image URL, width and height, thumbnail, title, source page and website. About 100 images per page, size, type and date filters, any country, only-new mode for schedules.

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

## Pricing

$2.10 / 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 any Google Images search into clean, structured data. Type a search such as `red sneakers` or `Alfons Mucha` and get, for every image, the **full-size image URL**, its **width and height**, the Google **thumbnail** with its size, the image **title**, the **page the image comes from**, the **website** and its display name, and the file size Google reports.

People also look for this as a **Google Images API**, a **Google image search API**, a **Google Images downloader**, a **reverse lookup of image sources** or a **bulk image URL extractor**. It returns about 100 images per Google page and pages through results automatically (typically 300 to 500 images per search before Google runs out). It runs without a browser, so a 100-image search usually finishes in 10 to 30 seconds.

This is an independent tool. It is not affiliated with, endorsed by or sponsored by Google. It reads the public image results that Google Search shows to anyone.

### What data you get

Every image is one row in the dataset. The fields below come from real test runs of the current build (22 test runs, 2,000+ images, US, German, Australian and Japanese searches).

| Field | Type | What it holds | Example |
|---|---|---|---|
| `query` | string | The search that found the image | `Alfons Mucha` |
| `position` | number | Rank of the image within this search (1 = first) | `1` |
| `imageId` | string | Google's ID for the result, stable for de-duplication | `eY1lodPgKK_mYM` |
| `title` | string | Title Google shows for the image (usually the page title) | `Alphonse Mucha - Simple English Wikipedia, the free encyclopedia` |
| `imageUrl` | string | Direct URL of the full-size original image | `https://upload.wikimedia.org/wikipedia/commons/b/bd/Alfons_Mucha_-_F._Champenois_Imprimeur-%C3%89diteur.jpg` |
| `imageWidth` | number | Width of the full-size image in pixels | `1202` |
| `imageHeight` | number | Height of the full-size image in pixels | `1633` |
| `thumbnailUrl` | string | Google's thumbnail of the image | `https://encrypted-tbn0.gstatic.com/images?q=tbn:…` |
| `thumbnailWidth` | number | Thumbnail width in pixels | `383` |
| `thumbnailHeight` | number | Thumbnail height in pixels | `522` |
| `contentUrl` | string | The web page that contains the image | `https://simple.wikipedia.org/wiki/Alphonse_Mucha` |
| `origin` | string | Domain of that page | `simple.wikipedia.org` |
| `source` | string | Website name as Google shows it | `Simple Wikipedia` |
| `fileSize` | string | File size Google reports for the original | `498KB` |
| `country` | string | Country code the search ran in | `us` |
| `scrapedAt` | string | ISO timestamp of the scrape | `2026-11-08T22:56:27.424Z` |

**Fill rates in testing:** every field above was filled for 100% of the images returned in all 22 test runs. The field names `query`, `origin`, `title`, `imageUrl`, `imageWidth`, `imageHeight`, `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight` and `contentUrl` match the names most Google Images tools in the Apify Store use, so you can switch without changing your pipeline.

### How to use it

1. Open the actor and click **Try for free** (or **Start**).
2. In **Search queries**, add one search per line, written the way you would type it into Google Images, e.g. `scandinavian bedroom`.
3. Set **Max images per query** (default 100). Google usually has 300 to 500 images for a search; the actor stops early when Google has no more.
4. Optionally choose a **Country** (`us`, `gb`, `de`, `au`, `jp` …) and **Language** (`en`, `de`, `ja` …) to get local results.
5. Optionally narrow the results with **Image size** (large, medium, icon), **Image type** (photo, clip art, line drawing, animated GIF) and **Time range** (past day, week, month or year).
6. Click **Start**. When the run finishes, open the **Output** tab and export the images as JSON, CSV, Excel, HTML or XML, or read them through the API.

### Input examples

**One search, 300 images** (the most common use):

```json
{
    "queries": ["Alfons Mucha"],
    "maxResultsPerQuery": 300
}
```

**Several searches at once, 100 images each:**

```json
{
    "queries": ["best CRM tools", "apify blog"],
    "maxResultsPerQuery": 100
}
```

**Large photos only, indexed in the past month:**

```json
{
    "queries": ["electric car"],
    "maxResultsPerQuery": 100,
    "imageSize": "large",
    "imageType": "photo",
    "timeRange": "month"
}
```

**Local results in another country and language:**

```json
{
    "queries": ["Brandenburger Tor"],
    "country": "de",
    "language": "de",
    "maxResultsPerQuery": 50
}
```

**Clip art and animated GIFs:**

```json
{
    "queries": ["cat"],
    "imageType": "clipart",
    "maxResultsPerQuery": 30
}
```

### Output example

Two real rows from a test run for `Alfons Mucha`:

```json
[
  {
    "query": "Alfons Mucha",
    "position": 1,
    "imageId": "eY1lodPgKK_mYM",
    "title": "Alphonse Mucha - Simple English Wikipedia, the free encyclopedia",
    "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/b/bd/Alfons_Mucha_-_F._Champenois_Imprimeur-%C3%89diteur.jpg?utm_source=simple.wikipedia.org&utm_campaign=index&utm_content=original",
    "imageWidth": 1202,
    "imageHeight": 1633,
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQVhXuJYPxErcnI2jtD1_tS_7CvlTzA2Icq_ga9vQe_yQ&s=10",
    "thumbnailWidth": 383,
    "thumbnailHeight": 522,
    "contentUrl": "https://simple.wikipedia.org/wiki/Alphonse_Mucha",
    "origin": "simple.wikipedia.org",
    "source": "Simple Wikipedia",
    "fileSize": "498KB",
    "country": "us",
    "scrapedAt": "2026-11-08T22:56:27.424Z"
  },
  {
    "query": "Alfons Mucha",
    "position": 2,
    "imageId": "-QkXi3QJNCOvqM",
    "title": "File:Alfons Mucha - 1896 - Spring.jpg - Wikimedia Commons",
    "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/6/6f/Alfons_Mucha_-_1896_-_Spring.jpg?utm_source=commons.wikimedia.org&utm_campaign=index&utm_content=original",
    "imageWidth": 508,
    "imageHeight": 1000,
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQimk4PYFaeFR1BFNMAMyybePMwmYuyScHECpZvFkd_4A&s=10",
    "thumbnailWidth": 318,
    "thumbnailHeight": 628,
    "contentUrl": "https://commons.wikimedia.org/wiki/File:Alfons_Mucha_-_1896_-_Spring.jpg",
    "origin": "commons.wikimedia.org",
    "source": "Wikimedia Commons",
    "fileSize": "237KB",
    "country": "us",
    "scrapedAt": "2026-11-08T22:56:27.507Z"
  }
]
```

### Use cases

- **Image SEO and brand monitoring.** See which pages and sites rank in Google Images for your product or brand terms, at which position, and track changes week by week.
- **Find where an image or product appears.** Search a product name and get every page (`contentUrl`) and website (`origin`) that shows it, e.g. to spot resellers or unlicensed copies.
- **Dataset building for machine learning.** Collect image URLs with their sizes for a list of labels, filter by size or type, then download the originals with your own tool.
- **Design and content research.** Gather mood-board references (interiors, logos, posters) with their sources so you can credit or license them.
- **E-commerce and market research.** See which retailers dominate visual search for a product category and how they present their products.
- **Feeding AI agents.** Give an agent a quick way to find candidate images and their source pages for a topic.

### Run it on a schedule and get only new images

1. Save your input as a **Task** in Apify Console.
2. Open the task's **Schedules** tab and run it daily or weekly.
3. Turn on **Only new images** (`"onlyNew": true`). The actor remembers every image URL it has returned (for 90 days, in a key-value store named `google-images-seen` in your account) and returns only images that are new since the last run. You pay only for those.
4. Add an integration (Slack, Google Sheets, a webhook) so new images arrive where you work.

### Integrations

**API (one call, returns the images):**

```
POST https://api.apify.com/v2/acts/daedal_quintuplet~google-images-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN
Content-Type: application/json

{"queries": ["red sneakers"], "maxResultsPerQuery": 100}
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("daedal_quintuplet/google-images-scraper").call(
    run_input={"queries": ["red sneakers"], "maxResultsPerQuery": 100}
)
for img in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(img["position"], img["imageUrl"], img["imageWidth"], "x", img["imageHeight"])
```

**JavaScript / Node.js** (`npm install apify-client`):

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('daedal_quintuplet/google-images-scraper').call({
    queries: ['red sneakers'],
    maxResultsPerQuery: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((img) => console.log(img.position, img.origin, img.imageUrl));
```

**No-code tools:**

- **n8n:** use the Apify node, choose *Run actor*, enter `daedal_quintuplet/google-images-scraper` and your input JSON, then read the dataset items.
- **Make:** use the Apify app's *Run an Actor* module, then *Get Dataset Items*.
- **Zapier:** use the Apify integration's *Run Actor* action, or trigger a Zap when a scheduled run finishes.
- **Google Sheets, Slack, webhooks:** connect them from the actor's **Integrations** tab in Apify Console.

**AI agents (MCP):** the actor is available through Apify's MCP server (`https://mcp.apify.com`). Add `daedal_quintuplet/google-images-scraper` as a tool and Claude, Cursor or any MCP client can search images on request. Every input field has a plain description and an example so the agent can fill it in.

### Pricing

Pay per result: **$2.10 per 1,000 images** ($0.0021 per image). Error rows are free. A 100-image search costs $0.21; 300 images cost $0.63. Platform usage is included in the price.

### Limits and error items

- Google shows a limited number of images per search, usually 300 to 500. When Google has no more, the actor stops and returns what it found; you are charged only for images returned.
- The first page sometimes holds 50 images instead of 100; the actor simply fetches the next page.
- `fileSize` is Google's rounded figure (e.g. `498KB`), not a byte count.
- The image files themselves are not downloaded; you get their URLs. Some sites block hot-linking, so download originals from your own server if you need the files.
- Bad input produces an **error row** instead of a crash, e.g. `{"error": true, "message": "\"country\" must be a two-letter country code such as \"us\", \"gb\" or \"de\" (got \"usa\")."}`. A search Google can't fetch after three tries gives `{"error": true, "query": "…", "message": "Failed to fetch Google Images: …"}`. Error rows are never charged; filter them out with `error != true`.
- If the platform restarts a run (a host migration), the actor resumes where it stopped and does not return or charge the same images twice.

### FAQ

**Do I need a Google account or API key?** No. The actor reads public Google Images results through Apify's Google SERP proxy, which is included in the price.

**How many images can I get per search?** Up to 500 per search with `maxResultsPerQuery`; in practice Google stops at 300 to 500 for most searches. Use several related searches to collect more.

**Can I filter by size, type or date?** Yes: `imageSize` (large, medium, icon), `imageType` (photo, clipart, lineart, animated) and `timeRange` (day, week, month, year). They map to Google's own *Tools* filters.

**Can I search in other countries and languages?** Yes. Set `country` to any two-letter code (`gb`, `de`, `fr`, `jp`, `au` …) and `language` to the interface language (`en`, `de`, `ja` …). Tested with US, German, Australian, British and Japanese searches.

**Is SafeSearch on?** Yes by default. Set `safeSearch` to `false` to turn it off.

**Can it find where my own photo appears (reverse image search)?** It searches by text, not by uploading an image. Search for your product or brand name to see which sites show it.

**Is it legal to scrape Google Images?** The actor collects publicly visible search results. The images themselves belong to their owners: check the license on the source page (`contentUrl`) before reusing an image.

**How fast is it?** About 5 to 10 seconds per Google page of up to 100 images.

### Related actors

More scrapers from the same developer:

- [Google Jobs Scraper](https://apify.com/daedal_quintuplet/google-jobs-scraper): Google Jobs listings for US and UK searches with salary, description and apply links.
- [Google Trends Scraper (all widgets)](https://apify.com/daedal_quintuplet/google-trends-scraper-all-widgets): interest over time, by region, related topics and queries.
- [Greenhouse Jobs Scraper](https://apify.com/daedal_quintuplet/greenhouse-jobs-scraper): every open job from any company's Greenhouse board, with salary ranges.
- [SEEK Australia Job Scraper](https://apify.com/daedal_quintuplet/seek-au-job-scraper): job listings from SEEK Australia.
- [SEEK New Zealand Job Scraper](https://apify.com/daedal_quintuplet/seek-nz-job-scraper): job listings from SEEK New Zealand.

# Actor input Schema

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

What to search for in Google Images, one search per line, written the way you would type it into Google. Example: \["red sneakers", "Alfons Mucha"].

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

The most images to return for each search. Google usually serves about 100 images per page; the actor stops early when Google has no more. Example: 100.

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

Two-letter country code Google should search from (Google's gl parameter), e.g. us, gb, de, au, in. Example: "us".

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

Interface language code (Google's hl parameter), e.g. en, de, fr, es. It affects titles Google shows. Example: "en".

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

Only return images of this size class. Example: "large".

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

Only return images of this type. Example: "photo".

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

Only return images Google indexed within this period. Example: "month".

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

Keep Google SafeSearch on (filters explicit images). Turn off only if you need unfiltered results. Example: true.

## `onlyNew` (type: `boolean`):

For scheduled runs: skip images (by image URL) already returned by earlier runs. Remembered for 90 days in the 'google-images-seen' key-value store of your account. Example: false.

## `debug` (type: `boolean`):

Save the raw Google HTML pages to the run's key-value store, for troubleshooting. Example: false.

## Actor input object example

```json
{
  "queries": [
    "red sneakers",
    "Alfons Mucha"
  ],
  "maxResultsPerQuery": 100,
  "country": "us",
  "language": "en",
  "imageSize": "large",
  "imageType": "photo",
  "timeRange": "month",
  "safeSearch": true,
  "onlyNew": false,
  "debug": false
}
```

# Actor output Schema

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

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

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

```

## MCP server setup

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