# Google Images Scraper (`blueskyscraper/google-images-scraper`) Actor

\[$3.50/1K images] Scrape Google Images search results: image URL, thumbnail, title, alt text, source site, page URL, width, height, aspect ratio, orientation, format. Many search terms and 213 countries per run, Google's size, color, type, time and licence filters. No run fee.

- **URL**: https://apify.com/blueskyscraper/google-images-scraper.md
- **Developed by:** [BlueskyScraper](https://apify.com/blueskyscraper) (community)
- **Categories:** SEO tools, AI, Developer tools
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

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

### Tested head-to-head — 18 Oct 2026

![Google Images Scraper tested head-to-head with the five most-used Google Images Actors](https://raw.githubusercontent.com/lergassy/apify-actor-assets/main/benchmarks/googleimages-tested-2026-10-18.png)

Same request for every Actor: 20 images for "bali beach", Google US:

| | This Actor | Five most-used Google Images Actors |
|---|---|---|
| Images returned (20 asked) | 20 | 0 (run failed) to 50 (limit ignored) |
| Countries per run | 213 | 1 |
| Google filters: size, colour, type, time, licence | Yes | 2 of 5 (one has the time filter only) |
| File format, file size and orientation | Yes | None (one gives file size only) |
| Start fee per run | None | None to $0.005 |
| Price per 1,000 images on the free plan | $2.80 | $0.11 to $3.51 (the most-used one: $3.51) |

Not the cheapest per image — the cheapest Actor returned 50 images when 20 were asked and gives no filters — but the only one with every country, every Google filter and the file facts in the same row.

### What is Google Images Scraper?

**Google Images Scraper** is a **Google Images API** for image search results. Type one or more search terms, pick one or more countries, and get one row per image from Google Images with the **direct image URL**, **Google's thumbnail**, **title**, **alt text**, **source website**, **page URL**, **page domain** and **image domain** — plus **width**, **height**, **aspect ratio**, **orientation**, **file format** and **file size** read from the image file itself. Every search term runs in every country you list, with that country's local results, in one run.

One row is one image. Results are read from Google Images through a licensed data provider, so there are **no proxies, CAPTCHAs or browser sessions to manage** on your side, and no Google account or API key is needed. Google's own image search tools are built in: **size**, **color** (including transparent background and black and white), **type** (clip art, line drawing, GIF), **time** and **Creative Commons licence**, plus **SafeSearch**.

- 💰 **$0.0028 per image** ($2.80 per 1,000) on the free plan, down to $0.00196 on paid plans — no start fee
- 🌍 **213 countries** and any number of search terms in **one run** (terms × countries)
- 📏 **Width, height, aspect ratio, orientation and format** in the same row — no second tool
- 🎛️ **Google's image filters**: size, color, type, time, usage rights, SafeSearch
- 🆓 **Error rows are free** — an unknown country or a search with no images costs nothing
- 🤖 Works from the **Apify API**, **MCP server** (Claude, ChatGPT, Cursor), n8n, Make and Zapier

### What data can Google Images Scraper extract?

| Field | Example | What it means |
|---|---|---|
| 🔍 `query` | `bali beach` | Search term the image was found for |
| 📍 `country` | `United States` | Country of the search (`countryCode`: `US`) |
| `position` | `5` | Position in the Google Images results (1 = first) |
| 🏷️ `title` | `10 Best Beaches in Bali - Which Bali Beach is Right For You?` | Title Google shows under the image |
| `alt` | `10 Best Beaches in Bali - …` | Alt text Google reports for the image. Google repeats the page title here for almost every result, so this column usually matches `title` |
| `sourceName` | `Hoteles.com` | Website name Google shows as the source |
| 🖼️ `imageUrl` | `https://cdn.sanity.io/images/…-1600x1066.jpg` | Direct URL of the full-size image file |
| `thumbnailUrl` | `https://encrypted-tbn0.gstatic.com/images?q=tbn:…` | Google's thumbnail of the image |
| 🔗 `pageUrl` | `https://en.hoteles.com/go/indonesia/best-bali-beaches` | Web page that contains the image |
| `pageDomain` | `en.hoteles.com` | Domain of that page, without www |
| `imageDomain` | `cdn.sanity.io` | Domain that hosts the image file (often a CDN) |
| `imageFileName` | `b7aace…-1600x1066.jpg` | File name from the image URL |
| 📏 `imageWidth` | `1600` | Width in pixels, read from the image file |
| 📏 `imageHeight` | `1066` | Height in pixels, read from the image file |
| `aspectRatio` | `1.501` | Width ÷ height |
| `aspectRatioLabel` | `16:9` | Simple ratio when the size is one (16:9, 4:3, 1:1, 4:5…) |
| `orientation` | `landscape` | `landscape`, `portrait` or `square` |
| `imageFormat` | `jpeg` | Format detected from the file bytes: jpeg, png, webp, gif, avif, heic, bmp, svg |
| `fileSizeBytes` | `314893` | File size when the host reports it |
| `sizeSource` | `image` | Where the size came from: `image`, `thumbnail` (shape only) or empty |
| `filters` | `type: gif; safesearch: on` | Google Images filters used for this search, or `none` when the search ran without filters |
| `language` | `English` | Google interface language of the search |
| `googleUrl` | `https://www.google.com/search?q=bali%20beach&udm=2&…` | The Google Images search that was read — open it to compare |
| `scrapedAt` | `2026-10-02T00:40:44.460Z` | When the row was produced |

**How width and height are measured.** Google Images does not hand out image dimensions in its results, so the Actor reads the first bytes of each image file (the header, not the whole picture) and takes the size, format and file size from there. Some hosts refuse such requests (Instagram previews are the usual case). For those images the **aspect ratio and orientation come from Google's thumbnail**, which keeps the original shape, `sizeSource` says `thumbnail`, and width and height stay empty. In our tests the file size was read for **16 of 20** images of the default search, **34 of 40** in a two-country run, **74 of 100** in a 100-image search and **10 of 10** in a GIF search; every image got an orientation.

### 💰 How much does it cost to scrape Google Images?

Google Images Scraper uses **pay-per-event** pricing. You pay for image rows only:

| Apify plan | Price per image | Per 1,000 images |
|---|---|---|
| Free | **$0.0028** | $2.80 |
| Bronze | $0.00252 | $2.52 |
| Silver | $0.00224 | $2.24 |
| Gold | $0.00196 | $1.96 |
| Platinum | $0.00196 | $1.96 |
| Diamond | $0.00196 | $1.96 |

- **No start fee** and no charge per run. Proxy and compute are included.
- **About 20% cheaper than the market leader** on the free plan ($2.80 vs $3.50 per 1,000 images, checked 18 October 2026), and cheaper again on paid plans.
- **$1 = about 357 images** on the free plan. Apify's free plan includes $5 of monthly credit — about **1,785 images a month**.
- **Error rows are free**: an unknown country or language, a search term with no letters, a search that returns no images.
- **Reading width, height and format costs nothing extra.** Switch it off only if you want faster runs.
- The default run (one search term, United States, 20 images) costs **$0.07**. It finished in **28 seconds** in our test; an identical repeat came back in 5 seconds.

Example budgets on the free plan:

| Job | Images | Cost |
|---|---|---|
| 1 search term × 1 country × 20 images | 20 | $0.07 |
| 10 search terms × 3 countries × 100 images | 3,000 | $10.50 |
| 500 product names × 1 country × 10 images | 5,000 | $17.50 |

### How to scrape Google Images with Google Images Scraper

1. Open the Actor and click **Try for free** (an Apify account is free).
2. In **🔍 Search terms**, type one search per line — exactly what you would type into Google Images.
3. In **📍 Countries**, add one or more countries by name or two-letter code.
4. Set **💯 Max images per search** (1–200).
5. Optionally pick Google's filters: **📐 Size**, **🎨 Color**, **🖼️ Type**, **🕒 Time**, **©️ Usage rights** and **🛡️ SafeSearch**.
6. Click **Start**. Rows appear in the **Overview** table with image previews; download them as CSV, Excel, JSON or HTML, or read them through the API.

### ⬇️ Input

#### Search terms in several countries (default)

```json
{
    "queries": ["bali beach"],
    "countries": ["United States"],
    "maxImagesPerQuery": 20
}
```

Every search term runs in every country: `["bali beach", "ubud rice terrace"]` × `["US", "ID", "DE"]` is six searches in one run. Countries accept a name or a two-letter code; all 213 countries Google serves are supported. Each country returns its own local Google Images results.

**Language** is optional. Empty means each country's main language (Germany → German, Indonesia → Indonesian, Japan → Japanese); set `"language": "en"` to search every country with the English interface.

**Max images per search** goes up to 200. Google Images shows about 100 images on the first screen; the Actor reads up to 200 per search. Search operators (`site:`, `filetype:`, `intitle:`…) are not accepted — type plain words and use the filters below.

#### 🎛️ Google Images filters

```json
{
    "queries": ["sunset"],
    "countries": ["DE"],
    "maxImagesPerQuery": 10,
    "imageType": "gif",
    "safeSearch": true
}
```

These are the filters from the **Tools** menu of Google Images, and Google applies them before it returns results:

| Field | Values |
|---|---|
| `imageSize` | `any`, `large`, `medium`, `icon` |
| `color` | `any`, `black_and_white`, `transparent`, or a color: `red`, `orange`, `yellow`, `green`, `teal`, `blue`, `purple`, `pink`, `white`, `gray`, `black`, `brown` |
| `imageType` | `any`, `clipart`, `line_drawing`, `gif` |
| `timeRange` | `any`, `past_day`, `past_week`, `past_month`, `past_year` |
| `usageRights` | `any`, `creative_commons` |
| `safeSearch` | `true` / `false` |

Filters combine: `"imageSize": "large", "color": "transparent"` returns large images with a transparent background. In our test the GIF search above returned **10 GIF files out of 10**, and in a transparent-background search for "bali beach" **93 of 100 image URLs pointed to PNG or WebP files** (19 of 100 in the same search without the filter). A filter that leaves nothing gives one free error row for that search, not a failed run.

#### 📏 Image size and format

`"readImageDetails": true` (default) adds `imageWidth`, `imageHeight`, `aspectRatio`, `aspectRatioLabel`, `orientation`, `imageFormat`, `fileSizeBytes` and `sizeSource`. Set it to `false` to get links only, a few seconds faster. The price is the same either way.

**Tip on short searches.** Each search has a fixed data cost whether it brings back 1 image or 100. The Actor works best with 10 or more images per search. Lists of hundreds of terms with only 1–3 images each can be stopped early by a built-in cost guard. The images already delivered stay in the dataset, and the stop note itself is a free row.

### ⬆️ Output

One row per image. A real row from the default search:

```json
{
    "type": "image",
    "query": "bali beach",
    "country": "United States",
    "position": 5,
    "title": "10 Best Beaches in Bali - Which Bali Beach is Right For You? - Go Guides",
    "alt": "10 Best Beaches in Bali - Which Bali Beach is Right For You? - Go Guides",
    "sourceName": "Hoteles.com",
    "imageUrl": "https://cdn.sanity.io/images/nxpteyfv/goguides/b7aace4cc92174202fc124385b608061719d1e31-1600x1066.jpg",
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRQDGKo0ikycMoyYu5c2i_oefbajLbXbJg62YV9z-sPTg&s=10",
    "pageUrl": "https://en.hoteles.com/go/indonesia/best-bali-beaches",
    "pageDomain": "en.hoteles.com",
    "imageDomain": "cdn.sanity.io",
    "imageFileName": "b7aace4cc92174202fc124385b608061719d1e31-1600x1066.jpg",
    "imageWidth": 1600,
    "imageHeight": 1066,
    "aspectRatio": 1.501,
    "aspectRatioLabel": null,
    "orientation": "landscape",
    "imageFormat": "jpeg",
    "fileSizeBytes": 314893,
    "sizeSource": "image",
    "filters": "none",
    "countryCode": "US",
    "language": "English",
    "googleUrl": "https://www.google.com/search?q=bali%20beach&udm=2&hl=en&gl=US&gws_rd=cr&ie=UTF-8&oe=UTF-8&uule=w+CAIQIFISCQs2MuSEtepUEUK33kOSuTsc",
    "scrapedAt": "2026-10-02T00:40:44.460Z"
}
```

The dataset has three table views:

- **Overview** — image preview, title, page URL, source, width, height, orientation, format.
- **Image size & format** — image URL, image domain, file name, width, height, aspect ratio, ratio label, orientation, format, file size and where the size came from.
- **Sources & SEO** — title, alt text, source name, page domain, image domain, page URL, thumbnail and filters: who ranks in Google Images for your terms.

`imageFormat` is the format of the file as it is served at `imageUrl`. Some CDNs serve a WebP or AVIF file behind a `.jpg` address, so the format can differ from the file extension. That is what you get when you download the URL.

### Use cases for Google Images data

#### Image SEO and rank tracking

See which pages and domains own the image results for your keywords in each country, with position, title and alt text. Track your own domain's images over time and study the titles and file names of the images that rank above yours.

#### Visual content research

Collect reference images for a brief, a mood board or a product shoot, filtered by size, color, orientation or type. Large, landscape and transparent PNGs for a design team are one input away.

#### AI and machine learning datasets

Build lists of candidate images for a classifier or a vision model: thousands of labelled image URLs with dimensions, format and source page, ready for your own downloader and licence review. The Creative Commons filter narrows the list to images Google marks as CC-licensed.

#### Brand and copyright monitoring

Search your brand, product or photographer name and see which websites show the images, in which countries, with the page URL for each. Useful for finding unlicensed reuse — then check each page.

#### Product and catalog enrichment

Run hundreds of product names and take the top images for each one, with the source domain, so a merchandiser can pick images to license or request from the brand.

### Integrations

#### Apify API (JavaScript)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('lergassy/google-images-scraper').call({
    queries: ['bali beach', 'ubud rice terrace'],
    countries: ['US', 'ID'],
    maxImagesPerQuery: 50,
    imageSize: 'large',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => [i.imageUrl, i.imageWidth, i.imageHeight]));
```

#### Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("lergassy/google-images-scraper").call(run_input={
    "queries": ["modern kitchen interior"],
    "countries": ["United Kingdom"],
    "maxImagesPerQuery": 100,
    "color": "white",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["imageUrl"], item["orientation"], item["pageDomain"])
```

#### One HTTP call

`POST https://api.apify.com/v2/acts/lergassy~google-images-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN` with the input JSON as the body returns the rows directly. That is the simplest way to use it as a Google Images search API from any language.

#### No-code tools

Connect the Actor to **Google Sheets**, **n8n**, **Make**, **Zapier** or a **webhook** from the Integrations tab. A scheduled run every morning for a list of keywords gives an image-SEO tracker without code.

#### MCP server

AI agents can call Google Images Scraper through the **Apify MCP server** (`https://mcp.apify.com`) from Claude, ChatGPT, Cursor and other MCP clients. The agent passes search terms, countries and filters, and gets back flat rows with image links, dimensions and sources.

### Error items / Troubleshooting

Problems become **free error rows** instead of failed runs:

| Error row | What to do |
|---|---|
| `Unknown country "…"` | Use a country name or a two-letter code (US, GB, DE, ID) |
| `Unknown language "…"` | Leave it empty, or use a name or code (English, en) |
| `Search operators such as site: … are not supported` | Type plain words; use the filters instead |
| `Google Images returned no images for this search` | The filters or the term leave nothing; loosen the filters |
| `Stopped early to cap data cost` | Raise Max images per search, or split a very long list |

An error row looks like `{ "type": "error", "input": "Narnia", "error": "Unknown country \"Narnia\"… Not charged.", "scrapedAt": "…" }`. A run summary (searches, images, sizes read, errors) is saved in the key-value store as `SUMMARY`.

### ❓ FAQ

#### Is it legal to scrape Google Images?

The Actor collects what Google Images shows any visitor: links, titles, alt texts and the pages images appear on. It does not log in or bypass anything. **The images themselves belong to their owners.** A link in this dataset is not a licence. Before you reuse, publish or train on an image, check its licence on the source page or ask the owner. If you are unsure, consult a lawyer about your use case.

#### Does the Creative Commons filter mean I can use the images?

No guarantee. It is Google's own usage rights filter. It limits results to images Google has marked as Creative Commons licensed — in our test, mostly Wikimedia Commons, Flickr and similar sites. Google's marking can be wrong or outdated, and CC licences come with conditions such as attribution or non-commercial use. Read the licence on `pageUrl` for every image you use.

#### Does Google Images Scraper download the image files?

No. It returns **links and metadata**, not files. To download Google Images in bulk, export the dataset and feed the `imageUrl` column to a downloader (for example `wget -i urls.txt`, a Python script or a no-code tool). The Actor reads only the first bytes of each file to measure its size and format. It does not store the pictures.

#### How many images can I get per search?

Up to **200 per search term per country**. Google Images shows about 100 images on its first screen. A search with filters may return fewer, and that is Google's answer, not an error. Use more search terms or more countries to collect more.

#### Why are width and height empty for some images?

Some websites refuse requests for their image files from outside a browser (Instagram previews do this). For those images `sizeSource` is `thumbnail`: the aspect ratio and orientation come from Google's thumbnail, and width, height and format stay empty.

#### How fresh are the results?

Each search is read from Google Images live when you run it. An identical search (same term, country, language, filters and number of images) repeated within 3 days is answered from a short cache and returns the same snapshot, at the same price. Change any input to force a new read.

#### Does it work without proxies?

Yes. You do not configure proxies, cookies or a browser, and Google blocks do not fail your run. Proxy and compute costs are included in the per-image price.

#### How much does it cost to scrape 1,000 Google Images results?

$3.50 on the Apify free plan, $2.18 on Bronze, down to $0.94 on Diamond. There is no start fee. Error rows and empty searches are free.

#### Can I use Google Images Scraper with the Apify API?

Yes. Every input field is available through the API, and the `run-sync-get-dataset-items` endpoint returns the rows in one call (see Integrations). Client libraries exist for JavaScript and Python.

#### Can I use it through an MCP server?

Yes. Add the Apify MCP server to Claude, ChatGPT, Cursor or any MCP client and ask for Google Images results. The agent sees the input fields with their descriptions and calls the Actor directly.

#### Can I integrate it with other apps?

Yes: Google Sheets, n8n, Make, Zapier, Slack, Airbyte, webhooks and anything that can call an HTTP API. You can also schedule runs from the Apify Console.

#### Do I get one row per image?

Yes. Every row is one image result for one search term in one country, with a `type` of `image`. Duplicates of the same image file within a search are removed. The only other row type is a free `error` row.

### Your feedback

Found a search that returns something different from Google Images in your browser, or need another field? Open an issue in the **Issues** tab with the input you used. We read every issue. If the Actor saves you time, a review on the Store helps other people find it.

### You might also like

| Actor | What it does |
|---|---|
| [Google Shopping Scraper](https://apify.com/blueskyscraper/google-shopping-scraper) | Google Shopping products with prices, sellers and ratings in 45 countries |
| [People Also Ask Scraper](https://apify.com/blueskyscraper/people-also-ask-scraper) | Google "People also ask" questions for any keyword, country and language — content and SEO research |
| [Pinterest Scraper](https://apify.com/lergassy/pinterest-scraper) | Pinterest pins with full-size images, outbound links and pinners, by keyword, board or profile |
| [Keyword Search Volume Checker](https://apify.com/blueskyscraper/keyword-search-volume-checker) | Google search volume, CPC and keyword difficulty for your image keywords |

# Actor input Schema

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

Enter one Google Images search per line, exactly as you would type it into Google Images (e.g. <code>bali beach</code>, <code>modern kitchen interior</code>, <code>golden retriever puppy</code>). Every search term runs in every country below. Plain words only: search operators such as <code>site:</code> or <code>filetype:</code> are not supported.

## `countries` (type: `array`):

Enter one country per line, by name or two-letter code (United States, US, United Kingdom, GB, Germany, DE, Indonesia, ID…). All 213 countries Google serves are supported. Each country is a separate Google Images search with that country's local results.

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

Set how many images to return for each search term in each country (1–200). Google Images shows about 100 images on the first screen; up to 200 are available per search.

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

Optional: Google interface language for every country, by name or code (English, en, German, de, Indonesian, id…). Leave empty to use each country's main language (United States → English, Germany → German, Japan → Japanese).

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

Choose Google's image size filter (Tools → Size on Google Images).

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

Choose Google's color filter (Tools → Color): black and white, transparent background, or a dominant color.

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

Choose Google's image type filter (Tools → Type).

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

Choose Google's time filter (Tools → Time): only images Google found within this period.

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

Choose Google's usage rights filter (Tools → Usage rights). Creative Commons limits results to images Google has marked as CC-licensed; always check the licence on the source page before reuse.

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

Switch on to filter explicit images with Google SafeSearch.

## `readImageDetails` (type: `boolean`):

Keep on to read the first bytes of each image file and add width, height, aspect ratio, orientation, file format and file size. Images whose host refuses the request get the aspect ratio and orientation from Google's thumbnail instead. Switch off for faster runs with links only. Same price either way.

## Actor input object example

```json
{
  "queries": [
    "bali beach"
  ],
  "countries": [
    "United States"
  ],
  "maxImagesPerQuery": 20,
  "imageSize": "any",
  "color": "any",
  "imageType": "any",
  "timeRange": "any",
  "usageRights": "any",
  "safeSearch": false,
  "readImageDetails": true
}
```

# Actor output Schema

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

One row per Google Images result: position, title, alt text, source site, image URL, thumbnail URL, page URL, page and image domain, width, height, aspect ratio, orientation, file format and file size.

# 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": [
        "bali beach"
    ],
    "countries": [
        "United States"
    ],
    "maxImagesPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("blueskyscraper/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": ["bali beach"],
    "countries": ["United States"],
    "maxImagesPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("blueskyscraper/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": [
    "bali beach"
  ],
  "countries": [
    "United States"
  ],
  "maxImagesPerQuery": 20
}' |
apify call blueskyscraper/google-images-scraper --silent --output-dataset

```

## MCP server setup

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