# Google Images Scraper - Filters, Licenses & Product Prices (`parseforge/google-images-scraper`) Actor

Scrape Google Images with every filter: full-size URLs, dimensions, source pages, license credits and product prices. Export to CSV, Excel, JSON or XML.

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

## Pricing

from $1.60 / 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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)

## 🖼️ Google Images Scraper

> 🚀 **Export Google Images results in seconds, with every filter Google offers.** Type a query and get up to about 400 images per search, each with the full-size image URL, exact dimensions, file size, source page and site, plus license credits for licensable images and price, brand and rating for product images. 39 fields per image.

This Actor runs your query on Google Images, exactly as a visitor from the country and language you choose would see it, and reads the data Google already attaches to each result: the original image, its thumbnail, the page it was found on, the publisher's name and favicon, the file size and the dominant color. When the image is licensable, Google also carries the license link, the credit line, the copyright notice and the creators, and when the image shows a product sold online it carries the product name, brand, price, currency and rating. The Actor keeps all of it.

Every Google Images Tools filter is available: size (including "larger than" from 400x300 up to 70 MP), color (black and white, transparent or 12 specific colors), type (faces, photos, clip art, line drawings, animated), time, usage rights (Creative Commons or commercial licenses), file type and SafeSearch, across 255 countries and 75 interface languages. In our test, "red fox" returned 350 images, "berliner dom" 312 and "nike air max 90" 223, which is everything Google shows for those searches.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| SEO and content teams | See which pages and sites own the image results for a keyword |
| Designers and marketers | Find Creative Commons images with the credit line ready to paste |
| E-commerce and brand teams | Track which retailers show your products in Google Images, at what price |
| AI and ML teams | Build labelled image datasets with source and license metadata |
| Researchers and journalists | Trace where an image appears and who publishes it |
| Agencies | Monitor image rankings per country and language |

### 📋 What the Google Images Scraper does

1. Takes one or more search queries.
2. Applies your Google Images filters, country and language, the same way the Tools menu on Google Images does.
3. Reads every page of results Google serves for each query, about 100 images per page, until Google has no more.
4. Returns one row per image with the full-size URL, dimensions, thumbnail, source page, domain, site name, file size, dominant color and favicon.
5. Adds license details (license link, where to get it, credit, copyright, creators) when the image is licensable.
6. Adds shopping details (product name, brand, price, currency, rating, description, Google Shopping link) when the image is a product, and duration and upload date when it comes from a video.
7. Never returns the same image twice for one query.

> 💡 **Why it matters:** the image URL alone tells you very little. Knowing who publishes an image, how big it is, whether you may reuse it and what it costs in a store is what turns an image search into data you can act on.

### 🎬 Full Demo (🚧 Coming soon)

### 📊 Output

Each dataset row is one image. 39 columns per row.

| Field | Type | Description |
|---|---|---|
| 🖼 `imageUrl` | string | Full-size original image URL |
| 📌 `title` | string | Title of the page the image is on |
| 🔗 `sourceUrl` | string | Page the image is on |
| 🆔 `imageId` | string | Google's ID for the image result |
| #️⃣ `position` | number | Rank in the results for this query (1 = first) |
| 📄 `page` | number | Results page the image came from |
| 🔍 `query` | string | The query that found it |
| ↔️ `imageWidth` | number | Original width in pixels |
| ↕️ `imageHeight` | number | Original height in pixels |
| 🖼 `thumbnailUrl` | string | Google's thumbnail |
| ↔️ `thumbnailWidth` | number | Thumbnail width |
| ↕️ `thumbnailHeight` | number | Thumbnail height |
| 🌐 `domain` | string | Domain of the source page |
| 🏷 `siteName` | string | Publisher name as Google shows it |
| 💾 `fileSize` | string | File size as Google reports it, for example `1.8MB` |
| 🕑 `publishedAgo` | string | How long ago Google says the page was published, for fresh results |
| 🎨 `dominantColor` | string | Dominant color as a hex code |
| ⭐ `faviconUrl` | string | Favicon of the source site |
| 📜 `isLicensable` | string | `Yes` when Google has license details for the image |
| 📜 `licenseUrl` | string | License terms, for example a Creative Commons deed |
| 🛒 `acquireLicenseUrl` | string | Where to get a license |
| 🏪 `acquireLicenseFrom` | string | Who sells or hosts the license |
| ✍️ `creditText` | string | Credit line |
| ©️ `copyrightNotice` | string | Copyright notice |
| 🛍 `isProduct` | string | `Yes` when the image is a product listing |
| 🛍 `productName` | string | Product name |
| 🏷 `brand` | string | Brand |
| 💲 `price` | number | Price |
| 💱 `currency` | string | Currency code |
| ⭐ `productRating` | number | Product rating |
| 📝 `productDescription` | string | Product description snippet |
| 🔗 `productUrl` | string | Google Shopping link for the product |
| 🎬 `isVideo` | string | `Yes` when the image is a video frame |
| 🎬 `videoDescription` | string | Video description snippet |
| ⏱ `videoDuration` | string | Video length |
| 📅 `videoUploadedAt` | string | Video upload date |
| 👤 `creators` | array | Creators named in the license metadata |
| 🕒 `scrapedAt` | string | When the row was collected |
| ❌ `error` | string | Populated only on failed rows |

License, product and video columns show `N/A` when the image is not that kind of result, and `Not Disclosed` when Google has the block but not that item.

#### Real sample records

A Creative Commons photo, searched with **Usage rights: Creative Commons** and **Size: larger than 2 MP**:

```json
{
  "imageUrl": "https://www.ross.no/wp-content/2020/02/20200204-DSC_7930-1-5.5.jpg",
  "title": "Hokkaido Red Fox (Vulpes vulpes ssp. schrencki) | morten ross",
  "sourceUrl": "https://www.ross.no/2020/02/04/hokkaido-red-fox-vulpes-vulpes-ssp-schrencki-4/",
  "imageId": "FQHtbSFiIqT6qM",
  "position": 2,
  "page": 1,
  "query": "red fox",
  "imageWidth": 5568,
  "imageHeight": 3712,
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTuJqg-YxOO5Q7_J-I9kEO0T8yo4Th5vbC95kV5tFfQSw&s=10",
  "thumbnailWidth": 678,
  "thumbnailHeight": 452,
  "domain": "www.ross.no",
  "siteName": "Morten Ross",
  "fileSize": "10.9MB",
  "publishedAgo": "Not Disclosed",
  "dominantColor": "#c09d86",
  "faviconUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTMhP6L1bYlaU9HlKa3EikiwahFtEEEt9VCyjYt0Yhhp_xFk7xUikInleE&s=10",
  "isLicensable": "Yes",
  "licenseUrl": "https://creativecommons.org/licenses/by/4.0/",
  "acquireLicenseUrl": "Not Disclosed",
  "acquireLicenseFrom": "Not Disclosed",
  "creditText": "Morten Ross",
  "copyrightNotice": "© Morten Ross",
  "isProduct": "No",
  "productName": "N/A",
  "brand": "N/A",
  "price": "N/A",
  "currency": "N/A",
  "productRating": "N/A",
  "productDescription": "N/A",
  "productUrl": "N/A",
  "isVideo": "No",
  "videoDescription": "N/A",
  "videoDuration": "N/A",
  "videoUploadedAt": "N/A",
  "creators": ["Morten Ross"],
  "scrapedAt": "2026-09-25T14:53:26.145Z",
  "error": null
}
```

A product image (non-applicable columns left out for brevity):

```json
{
  "imageUrl": "https://cdn-images.farfetch-contents.com/15/95/01/41/15950141_36455204_600.jpg",
  "title": "Nike Air Max 90 \"Wolf Grey\" Sneakers | Grey | FARFETCH",
  "sourceUrl": "https://www.farfetch.com/shopping/women/nike-air-max-90-wolf-grey-sneakers-item-15950141.aspx",
  "imageId": "C4Dphk55pmALHM",
  "position": 6,
  "page": 1,
  "query": "nike air max 90",
  "imageWidth": 600,
  "imageHeight": 801,
  "domain": "www.farfetch.com",
  "siteName": "Farfetch",
  "fileSize": "26KB",
  "dominantColor": "#babdc0",
  "isLicensable": "No",
  "isProduct": "Yes",
  "productName": "Nike Air Max 90 \"Wolf Grey\" Sneakers | Grey | FARFETCH",
  "brand": "Nike",
  "price": 156,
  "currency": "USD",
  "productRating": "Not Disclosed",
  "productDescription": "Shop Nike Air Max 90 \"Wolf Grey\" sneakers",
  "productUrl": "https://www.google.com/search?q=nike+air+max+90&prds=headlineOfferDocid:8714422148937828942,productDocid:8714422148937828942,pvo:4&ibp=oshop",
  "isVideo": "No",
  "creators": [],
  "scrapedAt": "2026-09-25T14:53:33.889Z",
  "error": null
}
```

A German search (**Country: Germany**, **Language: German**), non-applicable columns left out:

```json
{
  "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/c/c6/2023_Berliner_Dom_-_Westfassade_--_01.jpg?utm_source=de.wikipedia.org&utm_campaign=index&utm_content=original",
  "title": "Berliner Dom – Wikipedia",
  "sourceUrl": "https://de.wikipedia.org/wiki/Berliner_Dom",
  "imageId": "IFTqs2JdaInBMM",
  "position": 1,
  "page": 1,
  "query": "berliner dom",
  "imageWidth": 3704,
  "imageHeight": 2778,
  "domain": "de.wikipedia.org",
  "siteName": "Wikipedia",
  "fileSize": "1.8MB",
  "dominantColor": "#887862",
  "faviconUrl": "Not Disclosed",
  "isLicensable": "No",
  "isProduct": "No",
  "isVideo": "No",
  "creators": [],
  "scrapedAt": "2026-09-25T14:53:00.630Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Every Google Images filter.** Size, "larger than" thresholds up to 70 MP, black and white, transparent and 12 specific colors, image type, time, usage rights, file type and SafeSearch. Each one was checked against live results before it went into the input.
- **License data you can use.** With **Usage rights: Creative Commons**, every image in our test came back with its license link and credit line, so attribution is a copy-paste.
- **Shopping data on product images.** Product name, brand, price, currency and rating arrive on the same row as the image, with a Google Shopping link.
- **39 fields, not 10.** File size, dominant color, site name, favicon, position and page on top of the usual URL, dimensions and thumbnail.
- **Any country, any language.** 255 countries and 75 Google interface languages, so you see the image results a local visitor sees.
- **No duplicates.** Each image is returned once per query, even when Google repeats it across pages.
- **Fast and light.** Plain HTTP with no browser. A 5-image run finished in under 8 seconds in the cloud.

### 📈 How it compares to alternatives

| | This Actor | Typical Google Images scrapers | Saving images by hand |
|---|---|---|---|
| Fields per image | 39 | About 10 | What you copy |
| Size, color, type, time, license and file-type filters | All of them | Usually none | Yes, one search at a time |
| License link and credit line | Yes, when Google has them | No | Only by opening each page |
| Product price, brand and rating | Yes, on product images | No | No |
| Country and language | 255 countries, 75 languages | Sometimes | Your own location |
| Images per query | Everything Google shows, about 350 to 400 | Similar | Similar |

Google Images itself stops after roughly 350 to 400 images per query. That ceiling is Google's, and no scraper can go past it for a single search. To collect more, split the topic into several queries or combine the same query with different filters (sizes, colors, time ranges), which surfaces different images.

### 🚀 How to use

1. Create a free Apify account. New accounts include $5 of free platform credit, which is plenty to try this out: [console.apify.com/sign-up](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the Actor and go to the Input tab.
3. Add one or more search queries.
4. Set how many images to collect in total with **Max Items**, and optionally a limit per query.
5. Pick any filters, a country and a language.
6. Click **Start**. The log shows every page as it is collected.
7. Open the **Dataset** tab and download as CSV, Excel, JSON or XML, or pull it from the API.

```json
{
  "queries": ["red fox", "arctic fox"],
  "maxItems": 500,
  "imageSize": "larger-2mp",
  "usageRights": "cl",
  "country": "us",
  "language": "en"
}
```

### 💼 Business use cases

#### Image SEO and visibility tracking

Run your target keywords every week and see which domains own the image results, at which position, per country. `domain`, `siteName`, `position` and `page` make it a rank tracker for Google Images.

#### Royalty-free visuals with attribution

Content teams can search with **Usage rights: Creative Commons** and a minimum size, then filter the dataset by `licenseUrl`. The `creditText` and `creators` columns hold the attribution line, so publishing a correctly credited image takes seconds.

#### Retail and brand monitoring

Search your product names and see which retailers show them in Google Images, at what price and currency, with ratings. Spot unauthorised sellers and price gaps across countries by running the same query with different **Country** values.

#### Training data for AI

Collect large, labelled image sets with source, dimensions, file size and license on every row. Filter by license to keep only images you are allowed to reuse, and by size to drop thumbnails.

### 🔌 Automating Google Images Scraper

- **Make** and **Zapier**: run a search when a new keyword lands in a sheet and send the top images to your CMS.
- **Slack**: post new top-ranking images for your brand terms into a channel.
- **Airbyte**: sync datasets into Snowflake, BigQuery or Postgres and track image rankings over time.
- **GitHub**: schedule runs from Actions and keep versioned snapshots.
- **Google Drive**: drop a CSV or Google Sheet into a shared folder after every run.
- **API and webhooks**: every run emits a dataset ID; subscribe to the run succeeded webhook and pull the rows into any system.

### 🌟 Beyond business use cases

- **Research**: study how image results differ between countries and languages for the same query.
- **Personal**: find large, freely licensed wallpapers or reference photos for a project.
- **Non-profit**: source Creative Commons images for campaigns with correct credits.
- **Experimentation**: `dominantColor`, dimensions and file size make quick datasets for visual analysis.

### 🤖 Ask an AI assistant about this scraper

Paste this into ChatGPT, Claude or any assistant to get help designing your run:

> I am using the ParseForge Google Images Scraper on Apify. It takes search queries and returns one row per Google Images result, up to about 400 per query, with 39 fields including imageUrl, title, sourceUrl, position, imageWidth, imageHeight, domain, siteName, fileSize, dominantColor, license fields (licenseUrl, creditText, copyrightNotice, creators), product fields (productName, brand, price, currency, productRating) and video fields. It supports Google Images filters for size, larger-than thresholds, color, type, time, usage rights, file type and SafeSearch, plus country and language. Help me design a run to answer this question: \[your question here].

### ❓ Frequently Asked Questions

**🔢 How many images can I get per query?**
Everything Google Images shows for it, which is usually about 350 to 400 images. In our test, "red fox" returned 350. For more, use several related queries or the same query with different filters.

**🖼 Do I get the full-size image or just a thumbnail?**
Both. `imageUrl` is the original image on the publisher's site with its real width and height, and `thumbnailUrl` is Google's thumbnail.

**📜 How do I find images I am allowed to reuse?**
Set **Usage rights** to Creative Commons or to commercial and other licenses. Rows then carry the license link, credit line, copyright notice and creators when the publisher provides them. Always check the license page before reusing an image.

**🛍 When do product fields appear?**
When Google recognises the image as a product sold online. Shopping-style queries fill them often: 4 of the first 15 images for "nike air max 90" came with a price in our test. For other images they show `N/A`.

**🌍 Can I search as if I were in another country?**
Yes. Pick the **Country** and **Language**. The ranking and many of the images change with them.

**🎨 Which colors can I filter by?**
Black and white, transparent, and red, orange, yellow, green, teal, blue, purple, pink, white, gray, black and brown.

**📏 Can I get only high-resolution images?**
Yes. Use **Size** with a "larger than" value, from 400x300 up to 70 MP. Google applies the threshold to the image as it has indexed it.

**🔁 Will the same image appear twice?**
Not within one query. The Actor skips images Google repeats on later pages.

**⏱ How long does a run take?**
A few seconds per results page of about 100 images. A 5-image run took under 8 seconds in the cloud.

**💳 Am I charged for errors?**
No. Only images written to the dataset are charged. Error rows are free.

**📥 What export formats are supported?**
CSV, Excel, JSON, XML, plus direct API access and integrations with Make, Zapier, Airbyte, Slack, Google Drive and more.

**⚖️ Is this legal?**
The Actor collects image results Google shows to any visitor. The images themselves belong to their owners: check the license before reusing one, and comply with copyright law and Google's terms.

### 🔌 Integrate with any app

Every run writes to an Apify dataset reachable through a REST API, so the output drops into whatever you already use. Native integrations cover Make, Zapier, Airbyte, Slack, Google Drive, GitHub, Google Sheets and webhooks, and the API covers everything else.

### 🔗 Recommended Actors

- [Google Search Scraper - 23 Fields, Organic & Paid](https://apify.com/parseforge/google-search-scraper) - the web results for the same keywords.
- [Google Shopping Scraper - Product Prices & Offers](https://apify.com/parseforge/google-shopping-prices-scraper) - every offer for the products you find in images.
- [Google Lens OCR Scraper](https://apify.com/parseforge/google-lens-scraper) - read the text inside the images you collect.
- [Google Trends Scraper](https://apify.com/parseforge/google-trends-scraper) - pick the queries worth tracking.
- [Wikimedia Commons Valued Images Scraper](https://apify.com/parseforge/wikimedia-commons-valued-images-scraper) - curated, freely licensed images.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Google; only publicly available data.

# Actor input Schema

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

What to search on Google Images, one query per line. Each query is searched separately with the filters below. Google returns up to about 400 images per query.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Stop each query after this many images. Google Images itself shows about 350 to 400 images per query, so higher values return everything available.

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

Only images of this size class, as defined by Google Images.

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

Only images in this color.

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

Only images of this kind.

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

Only images Google found in this period.

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

Only images published under these licenses. Every image then comes with its license link and credit line.

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

Only images in this file format.

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

Google SafeSearch. "Default" keeps Google's own setting for the country.

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

Search Google Images as a user in this country. It changes which images rank first.

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

Language of the Google interface. Titles still come from the source pages.

## Actor input object example

```json
{
  "queries": [
    "red fox"
  ],
  "maxItems": 10,
  "maxResultsPerQuery": 400,
  "imageSize": "any",
  "color": "any",
  "imageType": "any",
  "timeRange": "any",
  "usageRights": "any",
  "fileType": "any",
  "safeSearch": "default",
  "country": "us",
  "language": "en"
}
```

# Actor output Schema

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

Image, source, size, license and price

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

Complete dataset with all 39 fields

# 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 fox"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 fox"],
    "maxItems": 10,
}

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

```

## MCP server setup

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