# Google Images Scraper - Source Pages & Prices (`webdata_labs/google-images-scraper`) Actor

\[$0.90 / 1K images] Scrape Google Images with the source page and its title, the domain, file size, dominant colour and exact dimensions - plus price, rating and brand on shopping results. Full filter set. No start fee.

- **URL**: https://apify.com/webdata\_labs/google-images-scraper.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** SEO tools, E-commerce, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.72 / 1,000 image returneds

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

Scrape Google Images into structured rows. Every image comes back with its full-resolution URL, its exact dimensions, **the page it appears on and that page's title**, the domain, the file size Google measured, and the image's dominant colour. Where Google recognises the image as a product, the row also carries the **price, the list price, the star rating, the review count and the brand**.

### ✅ What you get

- **The source page, not just the image.** Page URL, page title, site name and domain on every row.
- **File size and dominant colour** — `fileSize` as Google reports it (`14KB`, `1.2MB`), `dominantColor` as an `rgb()` triple.
- **Product data on shopping images.** Price, list price, currency, star rating, review count, brand, description and the Google Shopping link.
- **Exact dimensions** for both the full image and the thumbnail.
- **A provenance link** (`aboutThisImageUrl`) to Google's "About this image" page.
- **Google's own filters**: size, colour, type, file type, usage rights, recency, SafeSearch, single-domain, and 18 languages × 20 countries — each one checked against a live baseline, not assumed.
- **A working aspect-ratio filter**, applied here rather than by Google (see the limits below).
- **Partial-failure rows**, so one blocked search does not destroy a bulk run.

### ❌ What this isn't

This is not a reverse image search, an image downloader, or Google Lens. It does not fetch the image files themselves — it returns the URLs and the metadata around them.

### 🔎 Example tasks

- [Product images with prices and ratings](https://apify.com/webdata_labs/google-images-scraper/examples/product-images-with-prices)
- [Creative Commons images, large only](https://apify.com/webdata_labs/google-images-scraper/examples/creative-commons-large-images)
- [Images from one domain](https://apify.com/webdata_labs/google-images-scraper/examples/images-from-one-domain)

### 👥 Who it is for

SEO and content teams auditing which pages rank in image search; e-commerce teams watching how their products appear next to competitors'; designers and researchers building filtered image sets; anyone assembling a training or reference set who needs attribution, not just pixels.

### ⚙️ Input

Give it `queries` (one search term per line), or paste `searchUrls` straight from Google Images — a pasted URL keeps whatever filters you already set there. Everything else is optional: size, colour, type, aspect ratio, file type, usage rights, published-within, a single domain, SafeSearch, language and country. The prefilled input is a complete one-search run.

### 📤 Output

One row per image:

| Field | Example |
|---|---|
| `imageUrl`, `imageWidth`, `imageHeight` | `https://…/shoe.jpg`, 1872, 2340 |
| `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight` | `https://encrypted-tbn0.gstatic.com/…`, 225, 225 |
| `fileSize` | `14KB` |
| `dominantColor` | `rgb(42,48,48)` |
| `sourcePageUrl`, `sourcePageTitle` | the page the image is published on, and its `<title>` |
| `sourceDomain`, `siteName` | `www.adidas.com`, `Adidas` |
| `aboutThisImageUrl` | Google's provenance page for the image |
| `isProduct` | `true` on shopping results |
| `productTitle`, `productBrand`, `productPrice`, `productListPrice`, `productCurrency` | `199.99`, was `300`, `USD` |
| `productRating`, `productReviewCount`, `productDescription` | `4.59`, `81` |
| `googleShoppingUrl` | the product's Google Shopping page |
| `query`, `searchUrl`, `position`, `scrapedAt` | provenance for the row itself |

### 💵 Pricing

Pay per image returned. No start fee, no charge for a search that comes back empty.

### ⚠️ Honest limits

- **100 images per search is Google's ceiling, not ours.** There is no page two on Google Images: `&start=100` answers `200` with an empty result set. To go wider on one topic, run the same term under different filters (size, colour, recency) — each combination returns a different 100.
- **Product data covers roughly one row in eight.** That is the share Google itself tags as shopping results; the rest are ordinary web images and their commerce columns are left empty rather than guessed.
- **Google ignores its own aspect-ratio filter on image search, so this Actor applies it.** In a controlled run, asking Google for tall images returned 98 of the same 100 images as the unfiltered search and only 22 of them were actually portrait. Every row carries exact dimensions, so the filter is applied to the results instead — which means a narrow shape returns fewer than 100 rows, and you are only charged for the rows you get. Every other filter was confirmed to bite against the same baseline.
- **"Exactly WxH" is roughly four rows in five.** Google fills the remainder with near matches; the dimensions on each row tell you which is which.
- **`usageRights` reports what Google reports.** It reflects what the source site claims, it is not legal advice, and you should check the licence on the source page before reusing an image.
- **Results are personalised by locale.** The same query under a different `country` or `language` returns a different set, and product prices follow the country you choose.
- **A blocked search fails loudly.** A run where no search returned any image ends as FAILED rather than shipping an empty dataset as a success.

# Actor input Schema

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

One search term per line. Each term is a separate search and returns up to 100 images.

## `searchUrls` (type: `array`):

Paste Google Images search URLs straight from your browser. A pasted URL keeps its own filters, so use this when you have already narrowed a search on Google and want exactly that result set.

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

Google serves at most 100 images per search and has no page two, so 100 is the ceiling. Use filters below to reach different images for the same term.

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

Google's own size buckets. "Larger than" options return only images at least that big.

## `exactWidth` (type: `integer`):

Only used when image size is set to "Exactly". Both width and height must be set. Google honours this for roughly four rows in five and fills the rest with near matches.

## `exactHeight` (type: `integer`):

Only used when image size is set to "Exactly". Both width and height must be set.

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

Full colour, black and white, transparent background, or images dominated by one colour.

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

Photographs, clip art, line drawings, GIFs, or images containing faces.

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

Applied to the results, not sent to Google: Google accepts its own aspect filter on image search and then ignores it, so this Actor filters the rows itself using each image's exact dimensions. Narrow shapes therefore return fewer than 100 rows, and you are only charged for the rows you get.

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

Restrict results to one image format.

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

Google's own licence filter. It reports what the source site claims and is not legal advice - always check the licence on the source page before reusing an image.

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

Restrict results to images Google first saw within this window.

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

Restrict results to one site, e.g. wikipedia.org. Leave empty to search the whole web.

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

Google's explicit-content filter.

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

Google's hl parameter. Affects result titles and ranking.

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

Google's gl parameter. Results and product prices follow the country you pick.

## Actor input object example

```json
{
  "queries": [
    "running shoes"
  ],
  "searchUrls": [
    "https://www.google.com/search?q=vintage+posters&tbm=isch&tbs=isz:l,sur:cl"
  ],
  "maxResultsPerQuery": 100,
  "imageSize": "any",
  "imageColor": "any",
  "imageType": "any",
  "aspectRatio": "any",
  "fileType": "any",
  "usageRights": "any",
  "timePeriod": "any",
  "site": "wikipedia.org",
  "safeSearch": "off",
  "language": "en",
  "country": "us"
}
```

# Actor output Schema

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

One row per image: full-resolution URL, dimensions, file size, dominant colour, and the page it came from.

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

The subset Google recognises as products, with price, list price, rating and review count.

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

How many searches ran, how many images came back, and how many searches failed.

# 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": [
        "running shoes"
    ]
};

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

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

```

## MCP server setup

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