# Google Images Scraper — Original URLs, Source & Size (`khadinakbar/google-images-scraper`) Actor

Scrape Google Images by keyword: original full-resolution image URL, source page, thumbnail, title, dimensions, and product flag. Filter by size, type, color, and usage rights. Multi-query, 40+ countries. Managed SerpApi backend, HTTP-only, no login. MCP-ready.

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

## Pricing

from $2.00 / 1,000 image scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Images Scraper — Original URLs, Source & Size

Google Images Scraper by `khadinakbar` accepts keyword searches and returns one record per image found in Google Images results. Each record can include the original full-resolution image URL, thumbnail URL, source page URL, source name, title, pixel dimensions when known, and a product flag, plus the query and result position that produced it. This Apify Actor is usable through Apify MCP and works with a managed SerpApi backend over HTTP.

### Best fit and connected workflows

This Actor fits workflows that start with a keyword and need image-level records for the next step. It is a strong match for:

- image collection for research, taxonomy building, and dataset assembly
- ecommerce visual discovery where the product flag and source page support follow-up review
- design and content research where title, thumbnail, dimensions, and original URL are useful together
- agent workflows that need an Apify tool for image lookup by description through MCP
- Google-centered workflows that continue into [Google Maps Reviews Scraper](https://apify.com/khadinakbar/google-maps-reviews-scraper) when a returned Google record leads to a business or place and the next step needs reviews
- Use adjacent Google research with [Google Ads Scraper - Live Search Sponsored Ads](https://apify.com/khadinakbar/google-ads-scraper) or [Google Ads Transparency Scraper - Creatives & Run Dates](https://apify.com/khadinakbar/google-ads-transparency-scraper) when the next task is ad-focused rather than image-focused

### Practical scenario

Maya is preparing a mood board for a product launch. She starts with the keyword search `vintage neon sign` and sets `imageSize` to `large` so the results favor higher-resolution images. The run returns records with `imageUrl`, `thumbnailUrl`, `sourceName`, `sourcePageUrl`, `originalWidth`, `originalHeight`, and `isProduct`. Maya uses `sourcePageUrl` to open the hosting page, checks `imageUrl` for the direct file, and compares dimensions before choosing which references to include in the board.

### Input

Use keyword queries only. Each query is processed independently and can return up to the selected maximum number of images.

| Field | Type | Required | Description |
|---|---|---:|---|
| `queries` | array | Yes | One or more keyword searches run on Google Images. Google search operators such as quotes and `site:` also work. |
| `maxResultsPerQuery` | integer | No | Maximum number of images to return per query. Defaults to 100 and can go up to 500. |
| `country` | string | No | Two-letter ISO country code used for localized results. |
| `language` | string | No | Two-letter UI and result language code. |
| `safeSearch` | string | No | SafeSearch setting, either `off` or `active`. |
| `imageSize` | string | No | Image size filter: `any`, `large`, `medium`, or `icon`. |
| `imageType` | string | No | Image type filter: `any`, `photo`, `clipart`, `lineart`, `gif`, or `face`. |
| `imageColor` | string | No | Color filter: `any`, `color`, `grayscale`, or `transparent`. |
| `usageRights` | string | No | Google-reported usage rights filter: `any`, `creativeCommons`, or `commercial`. |

#### Example input

```json
{
  "queries": ["golden retriever puppy", "vintage neon sign"],
  "maxResultsPerQuery": 25,
  "country": "us",
  "language": "en",
  "safeSearch": "active",
  "imageSize": "large",
  "imageType": "photo",
  "imageColor": "color",
  "usageRights": "creativeCommons"
}
```

### Output

The Actor stores a dataset of image records. One record represents one image returned for one query.

| Field | Type | Description |
|---|---|---|
| `query` | string | Search query that returned the image. |
| `position` | integer | 1-based rank within the query results. |
| `title` | string or null | Image title or alt text reported by Google. |
| `imageUrl` | string or null | Direct URL to the original full-resolution image file. |
| `thumbnailUrl` | string or null | Google-hosted preview thumbnail. |
| `sourceName` | string or null | Website hosting the image. |
| `sourcePageUrl` | string or null | Web page where the image appears. |
| `originalWidth` | integer or null | Original image width in pixels when known. |
| `originalHeight` | integer or null | Original image height in pixels when known. |
| `isProduct` | boolean | Whether Google tagged the image as a shoppable product. |
| `scrapedAt` | string | ISO 8601 timestamp when the image was scraped. |

#### Illustrative output record

```json
{
  "query": "vintage neon sign",
  "position": 1,
  "title": "Vintage Neon Sign",
  "imageUrl": "https://example.com/images/vintage-neon-sign.jpg",
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:example",
  "sourceName": "example.com",
  "sourcePageUrl": "https://example.com/gallery/vintage-neon-sign",
  "originalWidth": 1920,
  "originalHeight": 1280,
  "isProduct": false,
  "scrapedAt": "2026-06-30T12:00:00.000Z"
}
```

### How it works

This Actor uses a managed SerpApi Google Images backend over HTTP. It accepts keyword queries, applies the selected filters, and paginates results up to 500 images per query. The live contract shows a primary charged event named `Image scraped`, and the dataset view presents the records as a table with query, rank, title, URLs, source, dimensions, and product flag.

### Pricing

This Actor uses Apify pay per event pricing plus Apify platform usage. Charges are event-based: one run start event and one `Image scraped` event for each returned image. For the current live amounts and the platform usage details, check the Pricing tab on this Actor page.

For example, a run that returns one hundred images includes one actor start event and one hundred image events. If you increase the number of queries or the per-query maximum, the number of returned records can grow accordingly.

### Use with AI agents (MCP)

Tool description: an Apify Actor tool for keyword-based Google Images lookup that returns structured image records with original URL, source page, thumbnail, title, dimensions, and product flag.

Exact Actor identity: `khadinakbar/google-images-scraper`

This Actor is usable through Apify MCP, so an agent can send a keyword and receive dataset-backed results with provenance preserved in the returned fields.

> Find Google Images for "vintage neon sign" in the US, return the top 20 results, and summarize the matches by source name and image dimensions. Keep the original image URL and source page URL in the records so I can review provenance.

Output interpretation:

- `imageUrl` points to the original file when Google provides it.
- `thumbnailUrl` is the Google preview image.
- `sourcePageUrl` points to the page hosting the image, which helps with provenance checks.
- `originalWidth` and `originalHeight` help compare resolution across results.
- `isProduct` identifies records Google marked as shoppable products.

Scope, pagination, and cost guidance:

- Use keyword queries, including multiple queries in one run.
- Increase `maxResultsPerQuery` when you want more results from a single query.
- The Actor paginates automatically until the selected per-query maximum is reached, up to 500.
- Cost scales with returned image records through the `Image scraped` event.

### Apify API example

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor("khadinakbar/google-images-scraper").call({
  queries: ["golden retriever puppy"],
  maxResultsPerQuery: 10,
  country: "us",
  language: "en",
  safeSearch: "active",
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
for (const item of dataset.items) {
  console.log(item.imageUrl);
  console.log(item.sourcePageUrl);
}
```

### Best results and outcome guidance

Choose keyword phrases that match the image topic you want to explore. If your task is visual sourcing, `imageSize: "large"` is a practical first filter. If you want photographs rather than graphics, use `imageType: "photo"`. If you are working with localized results, set both `country` and `language` to the region and UI language that fit the workflow. For brand-safe internal use, set `safeSearch: "active"`.

### Design note

I found that the dataset contract includes both `sourceName` and `sourcePageUrl`, which makes each image record easier to trace back to its hosting site and page.

### FAQ

#### Can I search with more than one keyword set in one run?

Yes. The `queries` input accepts an array, and each query is scraped independently.

#### What field tells me where the image came from?

Use `sourcePageUrl` for the page and `sourceName` for the hosting website.

#### Which field is the direct image file?

Use `imageUrl`. The `thumbnailUrl` is the small Google preview image.

#### How do I get more than one page of results?

Increase `maxResultsPerQuery`. The Actor paginates automatically up to 500 results per query.

#### Can I use this for image provenance checks?

Yes. The returned `sourcePageUrl`, `sourceName`, and `imageUrl` fields support provenance review in downstream workflows.

### Related Actors

- Use [Google Maps Reviews Scraper](https://apify.com/khadinakbar/google-maps-reviews-scraper) - useful after this Actor when a returned Google record points to a business or place and the next step needs reviews.
- Use [Google Ads Scraper - Live Search Sponsored Ads](https://apify.com/khadinakbar/google-ads-scraper) - a sibling workflow for Google ad research when the next step is sponsored search results.
- Use [Google Ads Transparency Scraper - Creatives & Run Dates](https://apify.com/khadinakbar/google-ads-transparency-scraper) - a sibling workflow for ad creative and run-date research.

### Responsible use

Use the returned image links and source pages in line with the source site's terms, Google's terms, and applicable copyright and licensing rules. The `usageRights` filter reflects Google's labeling and is useful for discovery, while the source page remains the place to verify the actual license before reuse or redistribution.

# Actor input Schema

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

One or more keyword searches run on Google Images (e.g. 'golden retriever puppy'). Each query is scraped independently and returns up to 'Max results per query' images. Accepts plain keywords; Google search operators like quotes and site: also work. NOT image URLs or page URLs — pass keywords only.

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

Maximum number of images to return for each query (e.g. 100). Google Images serves roughly 100 images per page; higher values paginate automatically. Defaults to 100, hard-capped at 500. This is per query, so 3 queries at 100 yields up to 300 images.

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

Two-letter ISO country code for localized image results (e.g. 'us', 'gb', 'de', 'jp'). Maps to Google's 'gl' parameter and biases results to that region. Defaults to 'us'. NOT a full country name — use the 2-letter code.

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

Two-letter UI/result language code (e.g. 'en', 'es', 'fr'). Maps to Google's 'hl' parameter. Defaults to 'en'. NOT a country code — this controls language, 'country' controls region.

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

Whether Google's SafeSearch adult-content filter is applied. 'active' filters explicit imagery; 'off' returns unfiltered results. Defaults to 'off'. Set to 'active' for brand-safe or workplace use.

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

Filter results by image dimensions. 'large' favors high-resolution images, 'icon' favors small ones, 'medium' is in between. Defaults to 'any' (no size filter). Use 'large' when you need print-quality originals.

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

Filter results by the kind of image. 'photo' returns photographs, 'clipart'/'lineart' return graphics, 'gif' returns animated images, 'face' returns headshots. Defaults to 'any'. Use 'face' for people, 'photo' to exclude illustrations.

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

Filter results by dominant color profile. 'color' returns full-color images, 'grayscale' returns black-and-white, 'transparent' returns images with a transparent background. Defaults to 'any'. Use 'transparent' to find PNG cut-outs for design work.

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

Filter by Google's reported licensing. 'creativeCommons' favors Creative Commons licenses, 'commercial' favors commercial & other licenses. Defaults to 'any'. Note: this reflects Google's labeling and is not a legal clearance — always verify the license on the source page before reuse.

## Actor input object example

```json
{
  "queries": [
    "golden retriever puppy",
    "vintage neon sign"
  ],
  "maxResultsPerQuery": 100,
  "country": "us",
  "language": "en",
  "safeSearch": "off",
  "imageSize": "any",
  "imageType": "any",
  "imageColor": "any",
  "usageRights": "any"
}
```

# Actor output Schema

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

No description

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

No description

## `runSummary` (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"
    ],
    "maxResultsPerQuery": 100,
    "country": "us",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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"],
    "maxResultsPerQuery": 100,
    "country": "us",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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"
  ],
  "maxResultsPerQuery": 100,
  "country": "us",
  "language": "en"
}' |
apify call khadinakbar/google-images-scraper --silent --output-dataset

```

## MCP server setup

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