# Google Images Scraper — Full-Size Image URLs & Sources (`experthasan/google-images-scraper`) Actor

Scrape Google Images for full-size image URLs, dimensions, titles and source pages. No API key, no headless browser.

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

## Pricing

from $0.12 / 1,000 image scrapeds

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/platform/actors/running/actors-in-store#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 — Full-Size Image URLs & Sources

Search Google Images and get back the **full-size image URLs**, not just thumbnails. No API
key, no Google Cloud project, no headless browser.

### What you get

Per image:

| Field | Coverage | Description |
| ----- | -------- | ----------- |
| `image_url` | Always | The full-size image, hosted at its original source |
| `width` / `height` | Always | Original dimensions in pixels |
| `title` | Most results | The image's title as Google shows it |
| `source_url` | Most results | The page the image appears on |
| `thumbnail_url` | Rarely | Google's thumbnail, when it serves one as a URL |

**On partial fields.** Google returns image search results as a page that doesn't pair every
image with its title in a machine-readable way. This Actor matches them by the image's host
domain, which resolves most results — around 7 in 10 on a typical query. Where an image is
served from a CDN unrelated to its source (a `history.com` article whose photo sits on
`cloudinary.com`, say), `title` and `source_url` are left `null` rather than guessed. A blank
field is recoverable; a confidently wrong one silently corrupts your dataset.

Every result always carries `image_url` and dimensions, so if that is what you need, coverage
is complete.

Results land in the run's dataset and export to JSON, CSV, Excel, XML or via the API.

### Pricing

| You pay for | Price |
| ----------- | ----- |
| Each image scraped | **$0.12 per 1,000** |
| Each results page requested | $0.004 |
| Actor start | $0.05 per 1,000 runs |

Google returns about 100 images per page, so 1,000 images works out to roughly **$0.16**.

**About the page fee.** Google Search is heavily bot-protected and every page fetch consumes a
paid proxy request whether or not it returns results. The $0.004 page fee covers that; a page
that comes back empty costs only the page fee, never the per-image fee.

Set a **maximum cost per run** and the Actor stops cleanly when it reaches it. Proxy and
compute are included — you are never billed separately for usage.

### Input

```json
{
  "queries": ["eiffel tower at night", "brutalist architecture"],
  "maxImagesPerQuery": 100,
  "imageSize": "large",
  "imageType": "photo",
  "safeSearch": "moderate",
  "country": "us",
  "language": "en"
}
```

| Field | Description |
| ----- | ----------- |
| `queries` | Search terms, one per line. Batch them — one run with 20 queries beats 20 runs. |
| `maxImagesPerQuery` | 1–500. Above 100 fetches extra pages, each billed as one page request. |
| `safeSearch` | `off`, `moderate` or `strict` |
| `imageSize` | `any`, `large`, `medium` or `icon` |
| `imageType` | `any`, `photo`, `clipart`, `lineart`, `gif` or `face` |
| `licence` | `any`, `creative_commons` or `commercial` |
| `country` / `language` | Google `gl` and `hl` codes |
| `proxyConfiguration` | Google SERP proxy is on by default. Leave it on. |
| `requestDelaySeconds` | Pause between requests (default 2) |

### Output

```json
{
  "type": "image",
  "query": "eiffel tower at night",
  "page": 1,
  "title": "Eiffel Tower at night - Wikipedia",
  "image_url": "https://upload.wikimedia.org/wikipedia/commons/a/a8/Tour_Eiffel.jpg",
  "thumbnail_url": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ABC",
  "source_url": "https://en.wikipedia.org/wiki/Eiffel_Tower",
  "source": "Google Images",
  "width": 3024,
  "height": 4032,
  "search_url": "https://www.google.com/search?q=eiffel+tower+at+night&udm=2&hl=en&gl=us"
}
```

Queries that return nothing are written as `{"type": "empty", ...}` and failures as
`{"type": "error", ...}`, so one bad query never kills the run.

### Common uses

- Build image datasets for training or evaluation
- Source reference imagery for design and moodboards
- Find where an image appears across the web via `source_url`
- Bulk-collect product or location photography
- Give an AI agent real image URLs instead of hallucinated ones (this Actor supports agentic
  payments via x402 and Skyfire)

### Integrations

Run on a schedule, or send output to Google Sheets, Airtable, Slack, Make, Zapier or your own
webhook. Everything is reachable through the [Apify API](https://docs.apify.com/api/v2) and
the JavaScript and Python clients.

### Notes and limits

- This is an **unofficial scraper**. Google changes its embedded result structure regularly;
  the parser uses a structural strategy with a regex fallback, and when a page yields nothing
  the Actor logs it and moves on rather than failing the run.
- **Keep the proxy on.** Google Search blocks unproxied traffic within a handful of requests.
- `title` and `source_url` are populated for most but not all results — see *On partial fields*
  above. `image_url` and dimensions are always present.
- `thumbnail_url` is usually `null`: Google inlines thumbnails into the page rather than
  serving them as URLs. Use `image_url` and resize on your side if you need small versions.
- The `licence` filter reflects Google's own labelling, which is a hint rather than a
  guarantee. **Always verify usage rights at the source before reusing an image.**
- Image URLs point at third-party servers and can go dead or change without notice.
- Scrape only public data and use the output in line with Google's terms, applicable law, and
  the copyright of each image's owner.

### Support

Found a bug or need a field that is not extracted yet? Open an issue on the Actor's **Issues**
tab.

# Actor input Schema

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

One query per line, e.g. `eiffel tower at night`.

## `maxImagesPerQuery` (type: `integer`):

Google returns roughly 100 images per results page. Asking for more than 100 fetches additional pages, and each page is billed as one `google-request`.

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

Google's SafeSearch filter level.

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

Filter by size. Leave as Any for no filter.

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

Filter by the kind of image.

## `licence` (type: `string`):

Filter by licence. Google's filter is a hint, not a guarantee — always verify rights at the source before reusing an image.

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

Two-letter country code, e.g. `us`, `gb`, `de`.

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

Two-letter language code for the results, e.g. `en`, `de`, `bn`.

## `proxyConfiguration` (type: `object`):

Google Images sits on Google Search, which is heavily bot-protected. The Google SERP proxy is enabled by default and is what makes runs succeed.

## `saveDebugHtml` (type: `boolean`):

Writes each raw Google response to the run's key-value store. Only useful when reporting a parsing problem — it adds storage cost, so leave it off for normal runs.

## `requestDelaySeconds` (type: `integer`):

Seconds to wait between consecutive Google requests. Raise this if you see blocked responses.

## Actor input object example

```json
{
  "queries": [
    "eiffel tower"
  ],
  "maxImagesPerQuery": 50,
  "safeSearch": "moderate",
  "imageSize": "any",
  "imageType": "any",
  "licence": "any",
  "country": "us",
  "language": "en",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  },
  "saveDebugHtml": false,
  "requestDelaySeconds": 2
}
```

# Actor output Schema

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

One item per image. `image_url`, `width` and `height` are always present; `title` and `source_url` are populated for most results, and are left null rather than guessed when the image's host domain cannot be matched to its source page.

## `imageUrls` (type: `string`):

The same dataset opened on the URLs view — just query, image URL and dimensions, for bulk downloading.

# 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": [
        "eiffel tower"
    ]
};

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

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

```

## MCP server setup

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