Google Images Scraper With Advanced Filters

Google Images Scraper — Photos, Metadata and Source Links

Google Images Scraper With Advanced Filters turns a list of keywords into structured image records pulled straight from Google Images: full-size imageUrl, thumbnailUrl, pixel dimensions, the title and contentUrl of the page hosting the image, and the site origin. It is built for teams who need many images per keyword rather than one — creative researchers, dataset builders, and catalog teams — and it narrows results with six of Google's own advanced filters (size, color, type, aspect ratio, file format, usage rights) so the dataset arrives already scoped to what you need. Results stream into your Output table row by row as they're found.

What is Google Images Scraper With Advanced Filters?

It's an Apify Actor that runs a Google Images search for each keyword you supply and returns one row per image found, with the image's URL, thumbnail, dimensions, source page, and site of origin. No Google account, API key, or login is required — the Actor queries Google Images directly over Apify Proxy and parses the results itself.

Key features:

• 🔎 Keyword-driven discovery — supply any number of search phrases; each is processed in order and every image row is tagged with the query that found it
• 🎛️ Six combinable filters — image size, color, type, aspect ratio, file format, and usage rights, merged into a single Google search request
• ⚡ Real-time streaming — each image is pushed to the dataset the moment it's parsed, not batched at the end of the run
• 🌐 Broadened collection — beyond the plain keyword, the Actor tries related autocomplete terms and rotates through filter facets to reach your target count when Google's default results page alone isn't enough
• 🛡️ Built-in retries and proxy rotation — failed or blocked requests retry automatically through Apify Proxy's GOOGLE_SERP group
• 📦 Standard dataset export — pull results as JSON, CSV, Excel, or via the Apify API, same as any Apify dataset

What data can I extract with Google Images Scraper?

Every image record carries identifying, sizing, source, and filter-context data — the fields below are the complete set the Actor writes to each row (read from src/main.py, not just the default table view).

Field	Example value	Use case
query	"nature"	Group results back to the keyword that found them
imageUrl	"https://example.com/photo.jpg"	Direct link to the full-resolution image
imageWidth	2048	Filter or sort by resolution
imageHeight	1366	Filter or sort by resolution
thumbnailUrl	"https://encrypted-tbn0.gstatic.com/images?q=tbn:..."	Fast preview without loading the full image
thumbnailWidth	300	Size of the preview asset
thumbnailHeight	200	Size of the preview asset
origin	"unsplash.com"	Identify which site is hosting the image
contentUrl	"https://unsplash.com/photos/abc123"	Visit the page the image was embedded on
title	"Misty mountain forest at dawn"	Read the caption or alt text Google indexed
appliedFilters	"itp:photo,ic:color"	See exactly which filters produced this row, or null if none were set

🔗 Source and attribution data

origin, contentUrl, and title tell you where an image actually lives on the web, not just where Google's cache points. That matters for two things: finding the full page an image came from (for citation, licensing checks, or further scraping) and telling apart images that only differ by hosting domain. A creative team pulling reference images for a mood board uses origin to group results by publisher before deciding which sources are worth crediting.

🎛️ Sizing and filter data

imageWidth, imageHeight, thumbnailWidth, thumbnailHeight, and appliedFilters are what you segment on after the run. Sort by imageWidth/imageHeight to drop anything below a print or web-resolution threshold, and use appliedFilters to confirm which combination of size/color/type/format/rights produced a given row — useful when a single run mixes multiple keywords or when you're auditing why a batch skewed toward one image type.

How does Google Images Scraper differ from the official Google API?

Google's own image search API is the Custom Search JSON API with searchType=image. Its hardest limit for bulk work is the results cap: Google's documentation states the num parameter accepts only integers between 1 and 10, so one authenticated request returns at most 10 images, no matter the query (checked on developers.google.com, 2026-07-30).

Feature	Custom Search JSON API (image search)	Google Images Scraper With Advanced Filters
Max results per query	10 per request	Up to maxImages (1–100,000), broadened automatically across related terms and filter facets
Setup requirement	API key + a configured Programmable Search Engine (cx)	queries only — no account or key
Free quota	100 queries/day, then paid	No Google-side quota; run cost follows Apify's pay-per-result pricing
Filter access	Size/color/type/rights params supported via query string	Same six filters exposed as select-list inputs, combined into one request
Output format	Raw JSON from Google's response schema	Normalized dataset row: same 11 keys on every image
Result delivery	Single JSON response per call	Streamed to the dataset row by row as the run executes

Why does the Custom Search API cap results at 10 per query?

Google's Custom Search JSON API was built for lightweight, per-user lookups, not bulk collection — the num parameter is documented as accepting only 1–10, and there is no offset mechanism to page past that ceiling within a single query the way a browser's infinite-scroll results page allows. In practice this means pulling a few hundred images for one keyword through the official API means issuing many separate requests, each burning against the 100-query free daily quota (or the $5/1,000-query paid tier, capped at 10,000/day). Google Images Scraper With Advanced Filters gets around this by working the way Google's own search page does: it fetches the search results page itself and, when a plain query doesn't return enough unique images, automatically retries with related autocomplete terms and different filter facets until it hits your maxImages target or Google genuinely has nothing more to show.

Use the Custom Search API when you need a small, occasional, officially-supported lookup and already have a configured Search Engine ID. Use this Actor when you need hundreds or thousands of images per keyword without provisioning API credentials or hitting the 10-per-query wall.

How to use data extracted from Google Images

🎨 Creative and design teams

Feed a shortlist of style keywords into queries, set imageType to itp:photo or itp:clipart, and pull imageUrl, title, and origin into a mood board or asset-sourcing sheet. Filtering by aspectRatio (iar:w for wide, iar:s for square) before download saves time cropping images that don't fit a layout.

🏢 Agencies auditing visual presence

Run the same keyword set on a recurring schedule and compare origin and contentUrl across runs to see which publishers keep showing up for a client's target terms, or whether a competitor's imagery is displacing the client's own on Google Images.

📊 Market research and visual trend analysis

Set imageColor or imageType per run and compare how many unique images appliedFilters produced for the same keyword — a fast way to see whether a topic is dominated by photography, clip art, or animated content, without opening a browser.

🤖 AI agents and automated pipelines

Point an agent at this Actor to source reference images for a given term, then pipe imageUrl values into a downstream vision model, embedding pipeline, or dataset-building script — the Actor's job stops at metadata collection, so downstream fetching and labeling stay under your control.

🔼 Input sample

Required per the input schema: queries.

Parameter	Required	Type	Description	Example value
queries	YES	array	List of search phrases. One query per line in the editor.	["nature", "product shots", "logos"]
maxImages	no	integer	Cap on unique images kept per keyword. Default 10, minimum 1, maximum 100000.	50
imageSize	no	string (select)	Filter by image size (Google isz:). Default "". Enum: "" (Any size), "isz:l" (Large), "isz:m" (Medium), "isz:i" (Icon), "isz:lt,islt:2mp" (Larger than 2 MP), "isz:lt,islt:4mp" (Larger than 4 MP), "isz:lt,islt:8mp" (Larger than 8 MP).	"isz:l"
imageColor	no	string (select)	Filter by color (Google ic: / isc:). Default "". Enum: "" (Any color), "ic:color" (Full color), "ic:gray" (Black & white), "ic:trans" (Transparent), "ic:specific,isc:red" (Red), "ic:specific,isc:orange" (Orange), "ic:specific,isc:yellow" (Yellow), "ic:specific,isc:green" (Green), "ic:specific,isc:teal" (Teal), "ic:specific,isc:blue" (Blue), "ic:specific,isc:purple" (Purple), "ic:specific,isc:pink" (Pink), "ic:specific,isc:white" (White), "ic:specific,isc:gray" (Gray), "ic:specific,isc:black" (Black), "ic:specific,isc:brown" (Brown).	"ic:color"
imageType	no	string (select)	Filter by image type (Google itp:). Default "". Enum: "" (Any type), "itp:photo" (Photo), "itp:clipart" (Clip art), "itp:lineart" (Line drawing), "itp:animated" (Animated (GIF)), "itp:face" (Face).	"itp:photo"
aspectRatio	no	string (select)	Filter by aspect ratio (Google iar:). Default "". Enum: "" (Any ratio), "iar:t" (Tall), "iar:s" (Square), "iar:w" (Wide), "iar:xw" (Panoramic).	"iar:w"
fileFormat	no	string (select)	Filter by file format (Google ift:). Default "". Enum: "" (Any format), "ift:jpg" (JPG), "ift:png" (PNG), "ift:gif" (GIF), "ift:webp" (WEBP), "ift:ico" (ICO), "ift:bmp" (BMP), "ift:svg" (SVG).	"ift:png"
usageRights	no	string (select)	Filter by usage/licensing rights (Google sur:). Default "". Enum: "" (Any usage rights), "sur:fc" (Free to use or share (commercial)), "sur:fmc" (Free to use, share or modify (commercial)), "sur:cl" (Creative Commons licenses), "sur:ol" (Commercial & other licenses).	"sur:cl"
proxyConfiguration	no	object	Apify Proxy configuration. Prefilled with useApifyProxy: true and apifyProxyGroups: ["GOOGLE_SERP"].	see below

Example input

{
  "queries": ["nature", "product shots", "logos"],
  "maxImages": 50,
  "imageType": "itp:photo",
  "imageColor": "ic:color",
  "usageRights": "sur:cl",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["GOOGLE_SERP"]
  }
}

⚠️ Common pitfall: each filter field is a single-select, not a list — you can pick one color, one type, one size, and so on per run, not several at once. Stacking narrow filters (for example imageType: "itp:animated" with imageColor: "ic:trans") also shrinks how many unique images actually exist for that combination, so maxImages becomes a ceiling the run may not reach, not a guaranteed count.

🔽 Output sample

Records are typed, normalized JSON with the same 11 keys on every row, written to your dataset in real time. Export as JSON, CSV, Excel, or HTML table from the Apify Console, or fetch programmatically via the Apify API or apify-client.

{
  "query": "nature",
  "imageUrl": "https://images.example.com/forest/misty-morning-2048.jpg",
  "imageWidth": 2048,
  "imageHeight": 1366,
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQabc123",
  "thumbnailWidth": 300,
  "thumbnailHeight": 200,
  "origin": "unsplash.com",
  "contentUrl": "https://unsplash.com/photos/misty-forest-morning",
  "title": "Misty forest morning light",
  "appliedFilters": "itp:photo,ic:color"
}

How do you filter and target specific images?

This is where the six advanced filters earn their place. They combine into a single Google tbs= query, so the targeting decision is really about which dimensions to fix and which to leave open.

Query phrasing carries most of the weight. Since there's no separate category input, the keyword itself is the primary targeting signal — "red sneakers product shot" returns a very different pool than "sneakers" filtered to ic:specific,isc:red. Use filters to narrow a keyword's results, not to replace picking a specific-enough keyword.

Scope precision comes from imageSize, aspectRatio, and fileFormat — pin down a minimum resolution, a layout-friendly shape, or a specific file type (SVG for vector assets, PNG for transparency) before you ever open a result.

Quality and compliance thresholds run through usageRights. Selecting a Creative Commons or commercial-use option filters to images Google has labeled as reusable — this reflects Google's own crawled label, not a verified license, so confirm on the source page (contentUrl) before commercial reuse.

Volume control is maxImages (1–100,000 per query). Past what a single search page returns, the Actor broadens automatically through related autocomplete terms and additional filter facets, stopping a keyword early once 14 consecutive fetches add no new unique image — so very narrow filter combinations on a niche keyword may return fewer rows than maxImages asks for, simply because Google has nothing more to show.

Three real targeting examples:

{ "queries": ["mountain landscape"], "maxImages": 200, "imageSize": "isz:l", "imageColor": "ic:color" }

Large, full-color landscape photography — a broad creative-reference pull.

{ "queries": ["company logo"], "maxImages": 30, "fileFormat": "ift:svg", "imageColor": "ic:trans" }

Transparent SVG marks only — scoped for reuse in design files.

{ "queries": ["coffee shop interior"], "maxImages": 100, "usageRights": "sur:cl", "aspectRatio": "iar:w" }

Wide, Creative Commons–labeled interior shots — scoped for a commercial mood board where reuse rights matter.

▶️ Want to try other scrapers?

Scraper	What it extracts
../../airbnb-images-scraper/airbnb-images-scraper	Listing photos and gallery metadata from Airbnb listings
../../Ebay-Search-Scraper/ebay-search-scraper-with-buyer-reviews-and-ratings	Keyword-searched eBay listings with buyer review data
../../Shein-Search-Products-Scraper/shein-search-products-scraper-by-category-store-and-product-url	Product search results filtered by category and store
../../Reddit-API-Scraper/reddit-api-scraper-with-comment-threads	Keyword/subreddit search results with nested comment threads
../../WhatsApp-group-links-Scraper/whatsapp-group-links-scraper-and-precision-search-filters	Filter-driven search results for public WhatsApp group listings

How to extract Google Images data programmatically

This Actor runs like any Apify Actor: one API call to start a run, then read the dataset back as structured JSON — no separate signup or credential beyond your Apify API token.

Python example

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("<your-username>/google-images-scraper-with-advanced-filters").call(
    run_input={
        "queries": ["nature", "technology"],
        "maxImages": 50,
        "imageType": "itp:photo",
        "usageRights": "sur:cl",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["query"], item["imageUrl"], item["title"])

Export to spreadsheets or CRM

Download the dataset as CSV directly from the Apify Console, or fetch it via the API and map columns as-is: query → keyword column, imageUrl → asset link column, title and origin → attribution columns. Because every row shares the same 11 keys, no reshaping is needed before importing into a spreadsheet or asset-tracking sheet.

Is it legal to scrape Google Images?

Yes — this Actor collects metadata about images that are already publicly indexed and displayed on Google Images and on the public pages that host them; it does not access any private or login-gated content. The records returned (URLs, dimensions, page titles, hosting domains) are business and product data about publicly published media, not personal data about individuals, so this falls under standard terms-of-service and database-rights considerations rather than GDPR or CCPA. That said, the images themselves remain the copyrighted work of their original creators or publishers — the usageRights filter reflects Google's own crawled labeling, not a verified license, so always confirm the actual license on the source page (contentUrl) before reusing an image commercially. Consult legal counsel for commercial applications involving bulk storage or redistribution of third-party copyrighted images.

❓ FAQ

Does this actor remove images that get taken down after the run?

No — each row reflects what Google Images returned at the moment the run collected it. If a source page later removes the image or goes offline, the dataset row still exists but imageUrl/contentUrl may stop resolving. Re-run the Actor for a current snapshot.

Can I get the source page along with the image itself?

Yes. Every row includes contentUrl (the page hosting the image) and origin (that page's domain), taken directly from Google's own result metadata — no separate lookup required.

How accurate is the licensing (usage rights) data?

The appliedFilters and usageRights values reflect exactly what Google's own crawler has labeled the image as, at request time. That labeling can be wrong or outdated, so validate the actual license on the source page before any commercial reuse — the standard downstream check for this kind of data.

How many images can I get per run?

Up to maxImages per keyword, from 1 to 100,000. Actual results can be lower than requested: the Actor stops broadening a keyword once 14 consecutive attempts (across related terms and filter facets) return no new unique image, meaning very niche keywords with narrow filters may return fewer rows than requested because Google genuinely has nothing more to show.

What makes the advanced filters different from a plain Google Images search?

The six filters (imageSize, imageColor, imageType, aspectRatio, fileFormat, usageRights) map directly to the same tbs= parameters Google's own search UI uses, but the Actor combines whichever ones you set into a single request and then automatically broadens the search — trying related terms and additional facets — to reach your target count, something a manual browser search doesn't do for you.

Does Google Images Scraper work with Claude, ChatGPT, and AI agent frameworks?

It's callable as a standard HTTP endpoint by any agent framework that can start an Apify Actor run and read back a dataset — there's no dedicated MCP server for this Actor, so integrate it the same way you would any REST-based tool call.

Can I use this Actor without a Google API key or developer account?

Yes. No Google account, API key, or Custom Search Engine ID is required — you only need an Apify account to run the Actor and read the results.

Can I download the actual image files, not just links?

This Actor returns image metadata and URLs (imageUrl, thumbnailUrl), not the binary files themselves. Pipe those URLs into a downloader script or a dedicated file-fetching Actor if you need the images saved locally.

Do results stream in during the run, or only at the end?

They stream in. Each image row is pushed to the dataset the moment it's parsed, so you can watch the count grow in the run log and start reading partial results before the run finishes.

Conclusion

Google Images Scraper With Advanced Filters turns a keyword list into a structured, filterable stream of image metadata — full-resolution links, dimensions, source pages, and Google's own size/color/type/format/rights labels — without needing a Google API key or hitting the official Custom Search API's 10-results-per-query ceiling. It suits creative teams sourcing references, agencies auditing visual presence, researchers mapping visual trends, and AI pipelines that need a reliable stream of image URLs to build on. Add your keywords, set the filters that matter, and start the run from the Apify Console or via the API.