# Google Images Scraper With Keyword Search (`scrapio/google-images-scraper`) Actor

Scrapes Google Images for any keyword, collecting image URLs, thumbnails, titles, source pages, resolutions, and metadata. Ideal for research, dataset creation, competitor analysis, inspiration gathering, and automated large-scale image collection from Google Search.

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

## Pricing

$14.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period. You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 — Extract Images, Thumbnails and Source Pages

Google Images Scraper With Keyword Search turns a list of keywords into a structured dataset of Google Images results — direct image URLs, thumbnails, dimensions, source pages, and site origins — one JSON row per image. Built-in search operators cover exact-phrase matching, excluded terms, OR keyword sets, and automatic related-keyword expansion through Google Autocomplete. Unlike a scraping framework that hands back raw HTML, it returns typed JSON streamed to your dataset in real time — ready for a spreadsheet, database, or LLM pipeline without any parsing. This guide covers every input and output field, and the workflows teams run it in: real-time enrichment, scheduled monitoring, and bulk dataset builds.

### 🧭 What Does Google Images Scraper With Keyword Search Do?

Google Images Scraper With Keyword Search runs a Google Images search for each keyword you provide and returns every matching image as a structured row. It talks to Google's public image search page directly — no browser automation, no Google account, and no API key required — so it behaves the same for one test keyword or a list of hundreds.

Each run can return:

- 🖼️ Full-size image links, with width and height in pixels
- 🌠 Thumbnail links, with their own separate width and height
- 🔗 The source page hosting the image (`contentUrl`) and its domain (`origin`)
- 📝 The title of the source page
- 🧾 The exact query string sent to Google for that row (`searchQuery`)
- 🌱 The specific term actually searched — your seed keyword or a related-keyword expansion (`searchKeyword`, `sourceKeyword`)
- ❝❞ Exact-phrase, exclude-term, and OR-keyword operators, applied before the request is sent

### ⚡ Features & Capabilities

The feature set splits into three groups: how you shape a search, how deep it digs per keyword, and what you get back on every row.

#### Core features

- **Multi-keyword runs** — `keywords` accepts a list; each seed keyword is searched in turn, and the log prints progress as each one finishes.
- **Query operators** — `exactPhrase` wraps the term in quotes, `excludeTerms` appends `-term` for each excluded word, and `anyOfKeywords` adds an `OR` group to the query. All three combine into a single query string that is saved verbatim on every row as `searchQuery`.
- **Related-keyword expansion** — `expandRelatedKeywords` fetches Google Autocomplete suggestions for each seed and searches those too, capped per seed by `maxRelatedPerKeyword`.
- **Facet cycling for depth** — internally rotates through a pool of Google's own image-search filters (photo/clipart type, color, size, aspect ratio, recency, and more) so a single keyword can keep surfacing new unique images instead of stopping at Google's first results page.
- **Per-keyword de-duplication** — the same image is never pushed twice within one keyword's search, including any related terms it expanded into.
- **Real-time streaming** — every row (`imageUrl`, `imageWidth`, `imageHeight`, `thumbnailUrl`, `thumbnailWidth`, `thumbnailHeight`, `title`, `contentUrl`, `origin`, `query`, `searchQuery`, `searchKeyword`, `sourceKeyword`) is pushed to the dataset as soon as it is parsed, not batched at the end of the run.
- **Automatic retries** — blocked or challenge pages are detected and retried against a new proxy session before a request is given up on.

#### Google Images Scraper With Keyword Search within the Scrapio data stack

Google Images Scraper With Keyword Search covers Google Images search results specifically — it does not download image files, and it does not scrape Google Shopping or Google web-search results. No other Scrapio Actor currently covers Google Images. For adjacent visual-data needs in the Scrapio suite: **Airbnb Images Scraper With Captions & Room Tags** pulls captioned photo galleries per listing, and **Ebay Search Scraper & Seller Store Details** and **Shein Search Products Scraper — Full Product Details** return keyword-searched product listings that carry their own image fields alongside price, condition, and seller data.

### Why do developers and data teams scrape Google Images?

#### 🏢 Marketing, SEO, and creative teams

Feed a list of product names, campaign topics, or brand terms into `keywords` and pull back `imageUrl`, `thumbnailUrl`, `title`, `contentUrl`, and `origin` for every result. Use `origin` to see which domains currently rank visually for a topic, `exactPhrase` to check coverage of a specific campaign slogan, and `excludeTerms` to strip out irrelevant clipart or stock-photo noise. The result lands as a flat dataset you can drop straight into a mood board, a content-gap audit, or a competitive visual-asset review — no manual screenshotting of search results pages.

#### 📊 AI training data and RAG indexing

`title`, `contentUrl`, and `origin` give every image a citation-ready context — the source page's headline and domain — while `imageUrl`, `thumbnailUrl`, and their width/height fields are structured primitives an embedding pipeline can consume directly. For **RAG enrichment**, attach the `title` + `contentUrl` pair to a record as retrievable context, with `origin` as the source-attribution field a model can cite back to the user. For **training data**, `searchKeyword` and `sourceKeyword` let you build weak-supervision labels — every image is already tagged with the term that surfaced it, so a keyword-labelled image set requires no separate annotation pass.

#### 📱 Competitive and market intelligence

Run the same keyword list on a schedule and compare `origin` and `imageUrl` between runs to see which domains are gaining or losing visual search visibility for a topic, brand, or product category. A new domain appearing in `origin` for a tracked keyword, or a previously ranking `imageUrl` disappearing, is a concrete, field-level signal rather than a manual spot-check.

#### 🔬 Research and academic use

Google Images Scraper With Keyword Search is well suited to building image corpora for visual, social, or market research — keyword-driven, publicly accessible results only. It does not access private albums, logged-in content, or anything behind a paywall; scope any research dataset to public data and cite your collection method accordingly.

#### 🎥 Product and SaaS development

The stable 13-field row shape makes this a workable backend for a lightweight image-search or reverse-lookup feature: keep `imageUrl`, `thumbnailUrl`, `title`, and `origin` for display, and use `sourceKeyword`/`searchKeyword` to route results back to the query a user typed.

### 🍚 Input Parameters

All parameters are optional — the schema defines no required fields; a run with no input at all falls back to the keyword `nature`.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `keywords` | No | array | List of seed keywords (e.g. nature, product shots, logos). One keyword per line. The base `queries` field is still accepted for backward compatibility. | `["electric car", "solar panel"]` |
| `queries` | No | array | Alternative to Keywords — accepted for backward compatibility with the base Google Images Scraper. Used only when Keywords is empty. | `["electric car"]` |
| `exactPhrase` | No | boolean | When ON, each keyword is wrapped in quotes so Google matches the exact phrase (e.g. "red sports car"). Default `false`. | `true` |
| `excludeTerms` | No | array | Each term here is appended as `-term` so results that mention it are filtered out (e.g. exclude "cartoon", "clipart"). | `["toy", "clipart"]` |
| `anyOfKeywords` | No | array | Broaden the search: these terms are joined with OR and added to every query, so results matching any of them are returned. | `["tesla", "rivian"]` |
| `expandRelatedKeywords` | No | boolean | When ON, Google Autocomplete suggestions for each keyword are fetched and searched too. Every row records which term was actually searched (searchKeyword) and your original seed (sourceKeyword). Default `false`. | `true` |
| `maxRelatedPerKeyword` | No | integer | Cap how many Google Autocomplete suggestions to expand for each seed keyword (only used when expansion is ON). Minimum `1`, maximum `20`, default `5`. | `5` |
| `maxImages` | No | integer | Cap how many unique images to keep for each search term. Minimum `1`, maximum `100000`, default `10`. The log shows progress toward this goal in real time. | `50` |
| `proxyConfiguration` | No | object | Keep the default proxy selection for best results. Prefilled to `{"useApifyProxy": true, "apifyProxyGroups": ["GOOGLE_SERP"]}`. | `{"useApifyProxy": true}` |

> ⚠️ The `maxImages` field's own description says "(1–1000)", but the schema's enforced range is `minimum: 1`, `maximum: 100000` — values above 1000 are accepted and processed. In practice, very large values are rarely reached: collection for a keyword stops early once 14 consecutive search attempts (across related terms and internal search filters) return zero new unique images, so real yield for a narrow or exhausted keyword can land well under `maxImages`.

#### Example input

```json
{
  "keywords": ["electric car", "solar panel"],
  "exactPhrase": true,
  "excludeTerms": ["toy", "clipart"],
  "anyOfKeywords": ["tesla", "rivian"],
  "expandRelatedKeywords": true,
  "maxRelatedPerKeyword": 5,
  "maxImages": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["GOOGLE_SERP"]
  }
}
```

#### Supported keyword formats and search operators

This Actor searches by keyword, not by URL — there is no URL input field. Three real examples:

- **Plain multi-keyword search:** `"keywords": ["nature", "product shots", "logos"]` — each keyword runs as its own search, in order.
- **Exact phrase, narrowed with exclusions:** `"keywords": ["red sports car"], "exactPhrase": true, "excludeTerms": ["toy", "clipart"]` — sent to Google as `"red sports car" -toy -clipart`.
- **Broadened with an OR group and related-keyword expansion:** `"keywords": ["electric car"], "anyOfKeywords": ["tesla", "rivian"], "expandRelatedKeywords": true` — sent as `electric car (tesla OR rivian)`, plus a second round of searches for whatever Google Autocomplete suggests for "electric car".

### 📦 Output Format

Every result is a flat, typed JSON row — no nested objects to unpack. The dataset's default table view surfaces all 13 fields the Actor writes; there is no hidden or trimmed data behind it. Thumbnail and source-page details are fields on this same row, not separate output objects, so there is a single output shape to document.

#### Output for image results

```json
{
  "query": "electric car",
  "imageUrl": "https://www.example-auto-blog.com/images/electric-car-2026.jpg",
  "imageWidth": 1600,
  "imageHeight": 1066,
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQabc123",
  "thumbnailWidth": 300,
  "thumbnailHeight": 200,
  "origin": "example-auto-blog.com",
  "contentUrl": "https://www.example-auto-blog.com/2026-electric-car-review",
  "title": "2026 Electric Car Review — Range, Price and Specs",
  "sourceKeyword": "electric car",
  "searchKeyword": "electric car",
  "searchQuery": "\"electric car\" -toy -clipart (tesla OR rivian)"
}
```

| Field | Description |
| --- | --- |
| `query` | The query label for the row (the seed keyword) |
| `imageUrl` | Direct link to the full-size image |
| `imageWidth` | Image width in pixels |
| `imageHeight` | Image height in pixels |
| `thumbnailUrl` | Preview thumbnail link |
| `thumbnailWidth` | Thumbnail width in pixels |
| `thumbnailHeight` | Thumbnail height in pixels |
| `origin` | Domain of the source page |
| `contentUrl` | Web page hosting the image |
| `title` | Title of the source page |
| `sourceKeyword` | The original seed keyword you typed |
| `searchKeyword` | The term actually searched — the seed, or a related-keyword expansion |
| `searchQuery` | The exact query string sent to Google for this row, including your operators |

#### Schema stability and export options

These 13 field names are defined by the Actor, not copied verbatim from Google's internal page structure, so they stay stable even if Google changes its front end. Export the dataset in any of Apify's standard formats — JSON, CSV, or Excel — from the Apify Console or via the API/`apify_client`, or read it programmatically as `Actor.push_data()` writes it, in real time.

### 💡 Google Images Scraper With Keyword Search Strategy Guide

#### 🎯 Strategy 1: Real-time enrichment pipeline

Trigger a run whenever a new record needs a visual reference — a new product SKU, a new brand mention, a new content topic. Run the Actor with `keywords` set to the record's name and a modest `maxImages` (5–10), then append the returned `imageUrl`, `thumbnailUrl`, and `title` fields back onto that record in your CRM, CMS, or database. Because rows stream in real time, a downstream process can start consuming results before the run finishes.

#### 🎯 Strategy 2: Scheduled monitoring and alerting

Use an Apify Schedule to re-run the same keyword list on a cadence you choose. Diff the new run's `origin` and `imageUrl` values against the previous run for the same `sourceKeyword`, and alert on the delta that matters to you — a new domain appearing in `origin` for a tracked keyword, or a previously surfaced image dropping out entirely.

#### 🎯 Strategy 3: Bulk dataset build

Feed a long list of keywords into `keywords` in a single run, or split a very long list across several concurrent runs. The Actor itself processes keywords sequentially within one run — there is no documented parallel-fetch setting — so splitting a large keyword list across multiple runs is the practical way to add concurrency. Aggregate the resulting datasets to CSV or a database for a research or training corpus.

#### Strategy comparison at a glance

| Strategy | Best for | Run pattern | Output format |
| --- | --- | --- | --- |
| Real-time enrichment | Attaching images to individual new records | Triggered, single keyword, small `maxImages` | Streamed JSON rows appended to a record |
| Scheduled monitoring | Tracking visual search-result changes over time | Apify Schedule, same keyword list, recurring | Dataset diffed run-over-run on `origin`/`imageUrl` |
| Bulk dataset build | Research or training corpora | One large keyword list, or split across runs | Dataset export to CSV/JSON |

### 🌴 Related Google Scrapers & Tools

| Scraper Name | What it extracts |
| --- | --- |
| Airbnb Images Scraper With Captions & Room Tags | Captioned, room-tagged photo galleries per Airbnb listing — the closest cross-platform match for pure image extraction |
| Ebay Search Scraper & Seller Store Details | Keyword-searched eBay listings with price, condition, images, and seller trust data |
| Shein Search Products Scraper — Full Product Details | Keyword-searched Shein products with a color-variant image gallery, pricing, and fit feedback |

### How to integrate Google Images Scraper With Keyword Search with your stack

Google Images Scraper With Keyword Search works with any language or tool that can make an HTTP request through the Apify API.

#### Python

```python
from apify_client import ApifyClient
import csv

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run_input = {
    "keywords": ["electric car", "solar panel"],
    "exactPhrase": False,
    "maxImages": 30,
    "expandRelatedKeywords": True,
}

## Replace with your Actor's full name as shown in the Apify Console
run = client.actor("YOUR_USERNAME/google-images-scraper-with-keyword-search").call(
    run_input=run_input
)

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

with open("google_images.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
    writer.writeheader()
    writer.writerows(rows)

print(f"Saved {len(rows)} image rows to google_images.csv")
```

#### Node.js

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

const client = new ApifyClient({ token: "<YOUR_APIFY_API_TOKEN>" });

const run = await client
  .actor("YOUR_USERNAME/google-images-scraper-with-keyword-search")
  .call({
    keywords: ["electric car", "solar panel"],
    maxImages: 30,
    expandRelatedKeywords: true,
  });

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Fetched ${items.length} image rows`);
console.log(items[0]);
```

#### Async and scheduled pipelines

For large or recurring jobs, use an Apify Schedule to run the Actor on a cron-style cadence instead of calling it synchronously, and poll the run status or dataset item count via `apify_client` until the run finishes. Apify can also fire a webhook on run completion so a downstream service is notified without polling.

### 🎯 Who Needs Google Images Scraper With Keyword Search? (Use Cases & Industries)

#### 🏢 Marketing and SEO teams

Search a product or campaign name, export `imageUrl`, `title`, and `origin`, and see which sites already rank visually for that term before launching a content or ad campaign.

#### 📊 AI and data teams

Use `title` and `contentUrl` as source-attributed context fields when enriching a RAG index, and `searchKeyword`/`sourceKeyword` as ready-made labels for a keyword-tagged image dataset.

#### 📱 Brand and competitive intelligence teams

Track `origin` for a brand or category keyword across scheduled runs to catch new competitors or content sites gaining visual search presence.

#### 🔬 Researchers

Build keyword-scoped image corpora for social, media, or market research from publicly accessible Google Images results only.

#### 🎥 Product and SaaS builders

Use the stable output schema as the data backend for an internal image-search, reverse-lookup, or visual-reference tool.

### Is it legal to scrape Google Images?

Scraping publicly accessible web data, including public search-engine results, is generally lawful in the United States. In *hiQ Labs, LLC v. LinkedIn Corp.*, 9th Cir., 2019 (reaffirmed on remand in 2022), the court held that accessing publicly available website data does not violate the Computer Fraud and Abuse Act. That precedent addresses access to public data broadly, not Google specifically, and does not resolve every jurisdiction or every claim.

Three separate questions apply here. Scraping public data has the legal footing described above. Violating a platform's Terms of Service is a separate matter — a civil contract risk between the user and the platform, not a criminal one. Data protection law is the third question: Google Images Scraper With Keyword Search returns image and web-page metadata (URLs, dimensions, titles, domains) rather than personal profile data, so GDPR's data-subject framing generally does not attach to the rows themselves — though the underlying images, being drawn from the open web, may incidentally depict identifiable people, and any downstream use of that content remains the user's responsibility.

Google Images Scraper With Keyword Search returns only publicly accessible data. What you do with that data is your responsibility — consult legal counsel for commercial applications involving personal data.

### ❓ Frequently asked questions

#### Does Google Images Scraper With Keyword Search work without a Google account?

Yes. It fetches Google's public image search page directly and needs no Google account, login, or API key.

#### How does Google Images Scraper With Keyword Search handle Google's anti-scraping measures?

It fetches pages with a browser-impersonating HTTP client (Chrome TLS fingerprint via `curl_cffi`), routes requests through Apify Proxy (the `GOOGLE_SERP` proxy group by default), and detects blocked or "unusual traffic" challenge pages automatically. A blocked request is retried up to 3 times, each attempt through a new proxy session, with a short backoff between attempts.

#### Can I run Google Images Scraper With Keyword Search at scale without getting blocked?

There is no published uptime or block-rate figure. The Actor rotates proxy sessions on every retry and processes keywords sequentially within a run; for very large keyword lists, splitting the list across multiple concurrent runs is the documented way to add throughput, since the code itself has no parallel-fetch setting.

#### How fresh is the data Google Images Scraper With Keyword Search returns?

Every run performs a live fetch against Google Images at run time — nothing is cached or replayed from a previous run.

#### Will maxImages always return that many results?

Not necessarily. Collection for a keyword stops early if 14 consecutive search attempts — across related-keyword expansions and internal search filters — add zero new unique images, so a narrow or already-exhausted keyword can return fewer rows than `maxImages` asks for.

#### Which fields work best for AI training and RAG indexing?

`title` and `contentUrl`/`origin` give citation-ready context for RAG. `searchKeyword` and `sourceKeyword` give every image a ready-made topic label for training data. All fields return as typed strings, integers, or booleans — no HTML or nested structures to normalize before use.

#### Is the same image deduplicated across a whole run?

Within one keyword's search — including any related terms it expands into — yes, the same `imageUrl` is never pushed twice. Across two *different* keywords in the same run, the same image can appear once per keyword, since de-duplication is tracked per keyword, not across the whole run.

#### Can I still use the legacy queries input?

Yes. `keywords` is read first; `queries` is used only when `keywords` is empty, so input built for the original Google Images Scraper keeps working unmodified.

#### Does Google Images Scraper With Keyword Search work with Claude, ChatGPT, and other AI agent tools?

It is callable as an HTTP endpoint through the Apify API by any agent framework that can make a request — there is no dedicated MCP server for this Actor. Every response is typed JSON, ready to drop into an LLM context window without parsing.

### ℹ️ Disclaimer

Google Images Scraper With Keyword Search extracts only publicly available data from Google Images. This tool is intended for lawful use cases only. Users are responsible for complying with Google's terms of service and applicable data protection laws in their jurisdiction.

# Actor input Schema

## `keywords` (type: `array`):

✍️ List of seed keywords (e.g. nature, product shots, logos). One keyword per line. The base `queries` field is still accepted for backward compatibility.

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

Alternative to Keywords — accepted for backward compatibility with the base Google Images Scraper. Used only when Keywords is empty.

## `exactPhrase` (type: `boolean`):

When ON, each keyword is wrapped in quotes so Google matches the exact phrase (e.g. "red sports car").

## `excludeTerms` (type: `array`):

Each term here is appended as -term so results that mention it are filtered out (e.g. exclude "cartoon", "clipart").

## `anyOfKeywords` (type: `array`):

Broaden the search: these terms are joined with OR and added to every query, so results matching any of them are returned.

## `expandRelatedKeywords` (type: `boolean`):

When ON, Google Autocomplete suggestions for each keyword are fetched and searched too. Every row records which term was actually searched (searchKeyword) and your original seed (sourceKeyword).

## `maxRelatedPerKeyword` (type: `integer`):

Cap how many Google Autocomplete suggestions to expand for each seed keyword (only used when expansion is ON).

## `maxImages` (type: `integer`):

🎚️ Cap how many unique images to keep for each search term (1–1000). The log shows progress toward this goal in real time.

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

⚙️ Keep the default proxy selection for best results.

## Actor input object example

```json
{
  "keywords": [
    "nature"
  ],
  "exactPhrase": false,
  "expandRelatedKeywords": false,
  "maxRelatedPerKeyword": 5,
  "maxImages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

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

All scraped items in the Actor's 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 = {
    "keywords": [
        "nature"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapio/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 = {
    "keywords": ["nature"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapio/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 '{
  "keywords": [
    "nature"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call scrapio/google-images-scraper --silent --output-dataset

```

## MCP server setup

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