# Google Images Scraper

Google Images Scraper returns one JSON row per image for any Google Images query: imageUrl (the original file on the source site), thumbnailUrl, width and height, title, sourcePageUrl, sourceDomain, sourceName and a 1-based position. It costs $1.50 per 1,000 images with no start fee, and at higher Apify plans $1.00 per 1,000. No browser or API key is needed, and it runs from the Apify Console, API or MCP.

## Key facts

- Price: from $0.0015 per image scraped, $1.50 per 1,000, down to $0.001 on higher Apify plans
- Pricing model: Pay per event
- Output: JSON, CSV, Excel, XML, RSS via Apify datasets
- Access: Apify Console, REST API, Python and JS clients, MCP tool google_images
- Version: Updated Nov 2026, build 0.1.3
- Usage: 1,145 runs, 100.0% successful runs (30 days)
- Actor: subimpact/google-images-scraper

## Who it is for

- Ecommerce and content teams researching how a product looks in image search
- Dataset builders assembling labelled image sets with source attribution
- SEO teams comparing image results across countries and languages
- Design and trend researchers tracking visual styles by keyword

## Use cases

### Build an attributed image dataset

Send queries such as ["red panda"] and each row carries imageUrl, sourcePageUrl, sourceDomain and sourceName, so every file keeps its provenance instead of arriving as an orphan download. Filter on width and height to keep only large originals, and use position to preserve Google's ranking order when you split the set into training and test groups.

### Compare image results by market

The gl input changes which sites Google returns, so run the same query with gl set to us and then my and diff sourceDomain lists. hl changes the interface language and the titles that come back. That shows which local publishers dominate a visual search in each market, which is useful evidence when you decide where to place a product image campaign.

### Find visual styles that rank

Use Google's own filters rather than guessing: imageSize large, imageType photo or animated, colour red, and timeRange month for recent results. Because the filters go to Google's index as its tbs parameter, the rows match what a person sees after clicking the same filter. Collect titles and sourceDomain to see which style and which site Google rewards for a keyword.

### Source images for a catalogue

When you need reference shots for a category page, run a batch of queries with maxImagesPerQuery set to 100 and keep width above a threshold. thumbnailUrl is Google's cached copy and imageUrl is the original, so the pair gives you a fallback when a host refuses hotlinking. The status field marks empty queries so a dud keyword does not look like a bug.

### Monitor where your assets appear

Run your product names as queries weekly and check whether your own domain appears in sourceDomain for the terms you care about. Because the rows keep position and sourcePageUrl, you can report which page of which query your image sits on, and whether a competitor image has taken the slot since the last snapshot.

## Price events

- Image scraped (`image-scraped`): $0.0015, lowest tier $0.001. One image row delivered: original image URL, thumbnail, width and height, title, source page and domain. Proxy and platform usage included. Empty and error rows are not charged.

Prices from the Apify Store. Apify shows the final price before each run.

## How it compares with other Apify actors

Price per 1,000 images at Apify Store list prices, checked 20 Nov 2026.

| Actor | Price per 1,000 images (Free plan) | Higher plans (Gold) | Start fee per run | Platform usage | Users | Rating | Last build |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Google Images Scraper (this API) | $1.50 | $1.00 | None | Included | 3 | No reviews yet | 20 Nov 2026 |
| [Google Images Scraper](https://apify.com/hooli/google-images-scraper) | $3.50 | $1.90 | $0.00005 | Included | 7,390 | 4.5 (15 reviews) | 18 Nov 2026 |
| [Google Images API - $0.10 per 1,000 - Fast Image API](https://apify.com/johnvc/google-images-api) | $0.11 | $0.11 | $0.00001 | Included | 850 | 5.0 (5 reviews) | 18 Nov 2026 |
| [✨ Google Images Scraper](https://apify.com/damilo/google-images-scraper) | $2.00 | $2.00 | None | Included | 772 | 4.8 (7 reviews) | 19 Nov 2026 |

### Where Google Images Scraper is stronger

- Larger user base and more monthly runs than the other image actors here
- Returns thumbnail width and height alongside the full image size
- Long standing listing with an established review history

### Where this API is stronger

- Search filters cover size, type, colour, safe search and time range
- Rows carry the source page URL and the source domain for attribution
- Takes several queries per run and reports a position for each image

Full comparison: Google Images Scraper vs this API: https://subimpact.net/apis/alternatives/hooli-google-images-scraper/

### Where Google Images API - $0.10 per 1,000 - Fast Image API is stronger

- Cached results carry a flag and age, so repeated queries are visible in the data
- Thumbnail dimensions are returned next to the full image size
- Output lists the source site and the page link for each image

### Where this API is stronger

- One charge per image, with no separate dataset storage event to budget for
- Search filters cover size, type, colour, safe search and time range
- Multiple queries run in one job, each row carrying its position

### Where ✨ Google Images Scraper is stronger

- Bills a single dataset item per image, which makes cost easy to predict
- Aimed at quick keyword lookups, returning image URLs and alt text
- Handy for building visual research or training sets from short runs

### Where this API is stronger

- Rows include exact pixel dimensions, thumbnail URL and the source page
- Search filters cover image size, type, colour, safe search and time range
- Each row records the position of the image in the search result list

The Store actors that return Google Images rows all bill per image, so the choice turns on fields and filters. hooli has the widest use and adds thumbnail dimensions, johnvc bundles a cache flag and a separate storage event, and damilo keeps a small field set. Ours adds search filters, source page attribution and a per image position.

Prices are Apify Store list prices, checked 20 Nov 2026. Platform usage 'Paid separately' means Apify bills compute on top of the event price. Check each listing before you buy.

## Input

- `queries` (array, required): One or more Google Images searches, e.g. `red panda` or `mid century modern sofa`. Each query returns up to `maxImagesPerQuery` images. Maximum 50 queries per run.
- `gl` (string, optional): Two-letter Google country setting, which decides the result set and the regional mix of sites: us, gb, my, sg, de, au, in. `uk` is accepted and mapped to gb.
- `hl` (string, optional): Google interface language: en, de, fr, ja, pt-BR, zh-CN, es-419. This is the language of the Google UI and of the titles Google returns.
- `maxImagesPerQuery` (integer, optional): How many images to return per query (1-500, default 50). Google serves about 100 images per page, so 50 costs one page per query. Google rarely serves more than a few hundred images for a query; the actor stops as soon as a page comes ba...
- `maxItems` (integer, optional): Global cost ceiling: the run stops after this many image rows across all queries (default 200, max 5000). At $0.0015 per image, 200 images cost $0.30 plus proxy usage. The default single query returns 50 images, so a default run costs ab...
- `safeSearch` (boolean, optional): Send Google's SafeSearch filter (safe=active). On by default — the Store version of this Actor should not return adult images. Turn it off only if you have a reason to.
- `imageSize` (string, optional): Google's own image-size filter. `large` returns the biggest originals (smallest short side measured: 674 px), `medium` the middle band, `icon` the small ones. Empty = any size.
- `imageType` (string, optional): Google's own image-type filter: photo, clipart (logos, drawings, PNG/SVG), lineart (black-and-white drawings) or animated (mostly GIFs). Empty = any type.
- `colour` (string, optional): Google's dominant-colour filter for the image itself, not for the query text. Empty = any colour.
- `timeRange` (string, optional): Only images from pages Google indexed recently: day, week, month or year. Useful for news and trends. Empty = any time.
- `concurrency` (integer, optional): How many queries are fetched in parallel (1-8, default 3). Pages of the same query are always fetched one after another. Higher is faster but uses more proxy sessions at once.

### Example input

```json
{
  "queries": [
    "red panda"
  ],
  "gl": "us",
  "hl": "en",
  "maxImagesPerQuery": 50,
  "maxItems": 200,
  "concurrency": 3
}
```

## Output fields

- `query` (string/null): The search query this image was found for, exactly as it was sent to Google.
- `position` (integer/null): 1-based position of the image within its query, in the order Google returned it (across pages, after duplicates were removed). Null on empty and error rows.
- `title` (string/null): Title Google shows for the image, which is normally the title of the page the image sits on. Null when Google provides none.
- `imageUrl` (string/null): Direct URL of the ORIGINAL full-size image file on the source site (not a Google thumbnail). Null on empty and error rows.
- `thumbnailUrl` (string/null): Google's own thumbnail on encrypted-tbn0.gstatic.com — small, fast and always reachable, useful for previews. Null when Google serves none.
- `width` (integer/null): Width of the original image in pixels, as reported by Google. Null when Google does not state a size.
- `height` (integer/null): Height of the original image in pixels, as reported by Google. Null when Google does not state a size.
- `sourcePageUrl` (string/null): URL of the web page the image appears on, i.e. where Google's result card links to.
- `sourceDomain` (string/null): Domain of the source page, e.g. en.wikipedia.org.
- `sourceName` (string/null): Site name Google displays for the result, e.g. Wikipedia, Instagram, National Geographic Kids.
- `scrapedAt` (string/null): ISO 8601 timestamp of when the query was fetched.
- `status` (string/null): ok for an image row (charged), empty when Google had no images for the query, error when the query failed (both delivered, never charged).
- `error` (string/null): Reason for an empty or error row. Null on image rows.

## Sample output

Trimmed from one of our own test runs. Personal data is redacted.

```json
[
  {
    "query": "red panda",
    "position": 1,
    "title": "Red Panda - SAFE Worldwide",
    "imageUrl": "https://safeworldwide.org/wp-content/uploads/2022/05/red-panda-2022-03-05-09-19-19-utc-scaled-e1653444292143-768x740.jpg",
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcT2_Z64mpT-r7D5_ueGW8FVDsUJ79nkKg-VzC4byVeW_g&s=10",
    "width": 768,
    "height": 740,
    "sourcePageUrl": "https://safeworldwide.org/red-panda/",
    "sourceDomain": "safeworldwide.org",
    "sourceName": "SAFE Worldwide",
    "scrapedAt": "2026-11-20T03:42:40.279Z",
    "status": "ok",
    "error": null
  },
  {
    "query": "red panda",
    "position": 2,
    "title": "Red Panda | National Geographic Kids",
    "imageUrl": "https://i.natgeofe.com/k/63b1a8a7-0081-493e-8b53-81d01261ab5d/red-panda-full-body_16x9.jpg?w=1200",
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTGvo_cV_NYgCn5uPBsrIsLRRcEFq8pGchNV9MXmHn1Ew&s=10",
    "width": 1200,
    "height": 675,
    "sourcePageUrl": "https://kids.nationalgeographic.com/animals/mammals/facts/red-panda",
    "sourceDomain": "kids.nationalgeographic.com",
    "sourceName": "National Geographic Kids",
    "scrapedAt": "2026-11-20T03:42:40.279Z",
    "status": "ok",
    "error": null
  }
]
```

## How to run it

1. Add one or more searches to queries, for example ["red panda"] or ["mid century modern sofa"]; a run accepts up to 50 queries.
2. Set maxImagesPerQuery, for example 50, which is one page of Google results, and maxItems as a ceiling for the whole run.
3. Optional: set gl to the country and hl to the interface language, then narrow with imageSize, imageType, colour or timeRange.
4. Start the run in the Apify Console; a page of about 100 images takes roughly 5 to 8 seconds, and queries run 1 to 8 in parallel.
5. Read imageUrl, thumbnailUrl, width, height and sourceDomain from the dataset, then export as JSON, CSV or Excel.

### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/subimpact~google-images-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["red panda"],"gl":"us","hl":"en","maxImagesPerQuery":50,"maxItems":200,"concurrency":3}'
```

### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/google-images-scraper").call(run_input={
      "queries": [
        "red panda"
      ],
      "gl": "us",
      "hl": "en",
      "maxImagesPerQuery": 50,
      "maxItems": 200,
      "concurrency": 3
    })

for item in client.dataset(run["default_dataset_id"]).iterate_items():
    print(item)
```

### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/google-images-scraper').call({
  "queries": [
    "red panda"
  ],
  "gl": "us",
  "hl": "en",
  "maxImagesPerQuery": 50,
  "maxItems": 200,
  "concurrency": 3
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

### MCP

```bash
claude mcp add subimpact-data -e APIFY_TOKEN=<YOUR_APIFY_TOKEN> -- npx -y @subimpact/data-mcp

# Then ask your agent to use the google_images tool.
```

### n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/google-images-scraper
Input JSON: paste the example input below.

## Limits

- Original image URLs can rot, block hotlinking or require a referer; the thumbnail is the more stable link.
- Google's result depth is finite, so a high maxImagesPerQuery is harmless but will not exceed a few hundred images per query.
- Google can serve a blocked page to a tired proxy IP; that query ends as an uncharged error row.
- Titles are Google's own, which for social posts is often the post text rather than a page title.

## FAQ

### What does an image row cost?

$1.50 per 1,000 images, about $0.0015 per row, with no start fee and no monthly charge; the lowest published tier is $1.00 per 1,000. You pay per delivered image row only, so empty queries and error rows cost nothing, and maxItems stops the run before a mistyped query can run up a bill.

### Do I need a Google API key or a browser?

Neither. The Actor fetches Google's Images view over plain HTTP and parses the page itself, so there is no headless browser, no Search API key and no code to maintain. Google's SERP proxy is included in the price, so you do not supply your own proxies either.

### How many images can one query return?

Google serves about 100 images per page, and the Actor keeps walking the result offset until it reaches maxImagesPerQuery or Google has nothing more. Expect up to a few hundred per query; the facts record 4 pages of results for cat before Google stopped. For wider coverage, add more queries rather than raising the cap.

### Why do some original image links stop working?

imageUrl points at the file on the source site, so a host that blocks hotlinking, needs a referer, or deletes the file will break the link. thumbnailUrl is Google's cached copy on gstatic and is more stable. Keep both and fall back to the thumbnail when the original fails.

### Are the width and height values reliable?

They are the dimensions Google reports for the indexed image and matched the real files in the checks recorded in the facts. If the source site replaces the file after Google indexed it, the numbers can drift from what you actually download, so verify before a bulk import.

### Is adult content filtered?

Yes, safeSearch is on by default and sends Google's safe=active setting. Turn it off deliberately if you need unfiltered results. The size, type, colour and time filters are Google's own and work the same way, applied in Google's index rather than after the fact.

### Can I run several queries in one go?

Up to 50 queries per run, with concurrency between 1 and 8 fetches in parallel, while pages of the same query stay sequential. maxItems caps total rows across all queries, defaulting to 200, so a large batch ends at a predictable cost.

## Links

- Page: https://subimpact.net/apis/google-images-scraper/
- Category: https://subimpact.net/apis/category/search-seo/
- Run on Apify: https://apify.com/subimpact/google-images-scraper
- All data APIs: https://subimpact.net/apis/
- Catalogue JSON: https://subimpact.net/apis/catalogue.json
