# Google Images Scraper - Usage Rights, Creative Commons Filter (`kamerozkan/google-images-scraper`) Actor

Google Images scraper for keyword lists. Get original full-size image URLs with width, height, file size, source page, site name and thumbnail. Filter by usage rights (Creative Commons or commercial), size, color, type and time. Pay only per image.

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

## Pricing

from $0.80 / 1,000 images

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 - Usage Rights, Creative Commons Filter

Google Images scraper with the filters other scrapers leave out: usage rights (Creative Commons or commercial licenses), size, color, type and time. For each keyword you get the original full-size image URL, width and height in pixels, file size, the source page, page title, site name, a thumbnail and the main color. Bulk queries, 18 Google countries, export to JSON, CSV or Excel.

### What does Google Images Scraper do?

Type the searches you care about (for example `mountain lake`, `modern kitchen design` or `site:unsplash.com coffee`), choose the filters you would use in Google Images, and the actor returns one row per image in Google's order. It reads further result batches when you ask for more images per query.

- **Usage rights**: only images Google marks as Creative Commons licensed, or only images with commercial and other licenses.
- **Size**: large, medium or icon, plus your own minimum width and height in pixels (images below it are dropped and not charged).
- **Color**: full color, black and white, transparent background or one main color (red, blue, green and 9 more).
- **Type**: photo, clip art, line drawing, GIF or face.
- **Time**: past 24 hours, week, month or year.

It needs no login, no Google account and no proxy setup on your side: pages are fetched through Apify's Google SERP proxy, which is included in the price.

### Who is it for?

- **Designers, marketers and bloggers**: find reusable Creative Commons images for a topic and go straight to the source page to check the license.
- **AI and machine learning teams**: build image datasets by keyword with original URLs, sizes and source pages.
- **E-commerce and brand teams**: see which images and sites rank in Google Images for your products and competitors.
- **SEO teams**: track image rankings and the pages behind them for your keywords.

### What data can you get?

| Field | Example |
|---|---|
| `query` | mountain lake |
| `country` | US |
| `position` | 1 (rank in Google Images for that query and filter set) |
| `imageUrl` | https://cdn.stocksnap.io/img-thumbs/960w/mountain-lake_PPC5CYC0DG.jpg |
| `width` / `height` | 960 / 1242 (pixels of the original image) |
| `fileSize` | 793KB (as Google shows it) |
| `title` | Mountain Lake Free Stock Photo - StockSnap.io |
| `sourcePageUrl` | https://stocksnap.io/photo/mountain-lake-PPC5CYC0DG |
| `sourceDomain` | stocksnap.io |
| `sourceName` | StockSnap.io |
| `thumbnailUrl` | Google's thumbnail of the image |
| `thumbnailWidth` / `thumbnailHeight` | 487 / 630 |
| `dominantColor` | rgb(11,21,24) |
| `googleImageId` | Google's ID for the result |
| `filters` | sur:cl,isz:l (the Google filters used, null when none) |
| `scrapedAt` | When the run collected the row |

Fields stay empty (null) when Google does not show that detail.

### How much does it cost?

You pay only for results: **$1.00 per 1,000 images** ($0.001 per image) on the Free plan, with Store discounts on paid Apify plans: Bronze $0.90, Silver $0.85, Gold and above $0.80 per 1,000 images. The Google SERP proxy is included; there is nothing else to buy. Images dropped by your minimum width or height are not charged.

Worked example: 50 keywords with 100 images each = 5,000 images = 5,000 x $0.001 = **$5.00** on the Free plan.

Set "Max images per query", "Max images in total" or a maximum cost per run to cap spending.

### How to use it

1. Click **Try for free**.
2. Enter one or more **Search queries**.
3. Pick **Usage rights**, **Size**, **Color**, **Type** and **Time** as you would in Google Images, and optionally a minimum width and height.
4. Choose the **Country** and, if you want, a **Language**.
5. Set **Max images per query** (one batch holds about 100 images; Google usually has 300 to 400 per query and filter combination).
6. Click **Start**, then download the results as JSON, CSV or Excel, or read them through the API.

### Input example

```json
{
  "queries": ["mountain lake", "modern kitchen design"],
  "usageRights": "creative_commons",
  "size": "large",
  "maxResultsPerQuery": 200
}
```

### Output example

Row from a QA run on 2026-10-24 (Creative Commons + large):

```json
{
  "query": "mountain lake",
  "country": "US",
  "position": 2,
  "imageUrl": "https://islandinthenet.com/wp-content/uploads/2015/11/Mountain-Lakes-Nature-Preserve_iPhone_20151031_1629.jpg",
  "width": 1280,
  "height": 720,
  "fileSize": "307KB",
  "title": "Mountain Lakes Nature Preserve - Island in the Net",
  "sourcePageUrl": "https://islandinthenet.com/mountain-lakes-nature-preserve-princeton/",
  "sourceDomain": "islandinthenet.com",
  "sourceName": "Island in the Net",
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQk5PNIwJ10hSG5G9Kk7wpW_urYy2SvXNL5EuoChCkyhg&s=10",
  "thumbnailWidth": 738,
  "thumbnailHeight": 414,
  "dominantColor": "rgb(72,46,34)",
  "googleImageId": "hFphKHlxSLzVvM",
  "filters": "sur:cl,isz:l",
  "scrapedAt": "2026-10-24T12:24:58.548691Z"
}
```

### Supported countries

United States, United Kingdom, Canada, Australia, India, Germany, Austria, Switzerland, France, Belgium, Netherlands, Italy, Spain, Poland, Sweden, Brazil, Mexico and Japan.

### Integrations and API

Run it from your code with the Apify API or the `apify-client` package, schedule it in Apify, or connect it to Make, n8n, Zapier, Google Sheets, Slack or a webhook.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("kamerozkan/google-images-scraper").call(run_input={
    "queries": ["coffee shop interior"],
    "usageRights": "creative_commons",
    "size": "large",
    "maxResultsPerQuery": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["width"], item["height"], item["imageUrl"], item["sourcePageUrl"])
```

### FAQ

**Can I use Creative Commons images for free?** The usage rights filter is Google's own filter. Creative Commons licenses differ (attribution, non-commercial, no derivatives), and Google can be wrong, so always check the license on `sourcePageUrl` before you reuse an image.

**How many images do I get per query?** One request returns about 100 images; the actor reads further batches until it reaches your limit or Google has no new images. Google usually has 300 to 400 images per query and filter combination. Use more specific queries or different filters to get more.

**Do I get the full-size image?** Yes. `imageUrl` is the original image on the source site, with its width and height. `thumbnailUrl` is Google's small preview.

**Does it download the image files?** No. It returns URLs and details. Download the files from `imageUrl` yourself if you need them, and respect the source site's license.

**What happens when a query has no results?** The run still succeeds; the status message and the OUTPUT record list the queries without results, and nothing is charged for them.

**Is it legal to collect this data?** It collects publicly visible search results (image links, sizes, page titles). You are responsible for how you use the data and the images, and for following the copyright rules that apply to you.

### Support and feedback

- Found a bug or missing a field? Open an issue on the **Issues** tab of this Actor. We reply within
  48 hours and ship most fixes within a few days.
- Have an idea for a feature? Issues are the fastest way to get it built.
- If the Actor saves you time, a short review on this page helps other users find it.

# Actor input Schema

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

Keywords to search in Google Images, one per line. Google search operators work, for example site:unsplash.com mountain lake.

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

Google's usage rights filter. 'Creative Commons licenses' returns images Google marks as CC licensed; 'Commercial and other licenses' returns images with licensing info such as stock photos. Always check the license on the source page before you reuse an image.

## `size` (type: `string`):

Google's size filter. 'Large' usually means 1000 px or more on the long side.

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

Google's color filter: full color, black and white, transparent background or one main color.

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

Google's type filter.

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

Only images Google found in this time window.

## `minWidth` (type: `integer`):

Drop images narrower than this. Dropped images are not charged. 0 keeps all.

## `minHeight` (type: `integer`):

Drop images lower than this. Dropped images are not charged. 0 keeps all.

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

Google country edition. Ranking and sources follow this country.

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

Interface language code such as en, de or fr. Leave empty to use the country's main language.

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

Filter explicit results (Google SafeSearch).

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

Stop each query after this many images. One results page holds about 100 images; the actor pages further when you ask for more. Google usually returns 300 to 400 images per query and filter combination.

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

Stop the whole run after this many images. You are charged per image, so this also caps the cost of the run.

## Actor input object example

```json
{
  "queries": [
    "mountain lake"
  ],
  "usageRights": "any",
  "size": "any",
  "color": "any",
  "imageType": "any",
  "timeRange": "any",
  "minWidth": 0,
  "minHeight": 0,
  "countryCode": "us",
  "safeSearch": true,
  "maxResultsPerQuery": 50,
  "maxItems": 1000
}
```

# Actor output Schema

## `results` (type: `string`):

One row per result in the default dataset.

# 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": [
        "mountain lake"
    ],
    "maxResultsPerQuery": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("kamerozkan/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": ["mountain lake"],
    "maxResultsPerQuery": 50,
}

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

```

## MCP server setup

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