# Google Lens Reverse Image Search Scraper (`automation-lab/google-lens-scraper`) Actor

Reverse image search with Google Lens: visual and exact matches with page URL, title, source, thumbnail and price for each image.

- **URL**: https://apify.com/automation-lab/google-lens-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, AI
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.52 / 1,000 match returneds

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

## Google Lens Reverse Image Search Scraper

Find where an image appears online and which products look like it. Give the Actor image links; it runs each one through Google Lens and returns one row per match, with the page link, title, site, thumbnail, the full-size matching image, and the price and stock text Google shows for shopping results.

### What does this Actor do?

- **Visual matches**: pages with similar-looking images, the same results as the "Visual matches" tab in Google Lens. Shopping results include price text such as `$100*`, a parsed price and currency, and stock text such as `In stock`.
- **Exact matches**: pages that contain the same image, with the image size and the date Google shows. Use them to track copies of your photos.
- Each row says whether it is a `visual` or `exact` match, and gives its rank on that tab.
- You pay per match returned. Images with no matches add nothing.

It does not return the text in an image (OCR). For that, use [Google Lens OCR](https://apify.com/automation-lab/google-lens-visual-matches-and-detected-text).

### Who is it for?

- **Ecommerce and dropshipping teams** checking where a product photo is sold and at what price.
- **Brand protection teams** finding copies of their product photos on other stores and marketplaces.
- **Photographers and media teams** tracking where their images are reused.
- **Researchers** checking the source of an image.

### Input

| Field | Description | Default |
| --- | --- | --- |
| `imageUrls` | Direct links to the images, up to 500 per run | required |
| `matchTypes` | `visual`, `exact` or both | both |
| `maxMatchesPerImage` | Most matches per image and match type, 1 to 100 | 20 |
| `country` | Two-letter country for local results and prices | `us` |
| `language` | Language of titles and the Google interface | `en` |

```json
{
    "imageUrls": ["https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"],
    "matchTypes": ["visual", "exact"],
    "maxMatchesPerImage": 20,
    "country": "us",
    "language": "en"
}
```

### Output

One row per match:

```json
{
    "imageUrl": "https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600",
    "imageIndex": 1,
    "matchType": "visual",
    "rank": 4,
    "pageUrl": "https://shopify.jharr.is/products/red-shoes",
    "title": "Red shoes – Jon's Development Store",
    "source": "Jon's Development Store",
    "domain": "shopify.jharr.is",
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcQ795-aOcftOJCQbd-yOO8qLKhy8xG0BVH9Zw&s",
    "matchImageUrl": "https://shopify.jharr.is/cdn/shop/products/revolt-164_6wVEHfI-unsplash.jpg",
    "matchImageWidth": 1946,
    "matchImageHeight": 1297,
    "priceText": "$100*",
    "price": 100,
    "currency": "USD",
    "inStockText": "In stock",
    "publishedDate": null,
    "lensUrl": "https://www.google.com/search?vsrid=...",
    "scrapedAt": "2026-11-13T07:20:00.000Z"
}
```

Exact matches have `matchType` `exact`. They carry `matchImageWidth`, `matchImageHeight` and often `publishedDate`. Google does not show them a full-size image link or thumbnail, so `matchImageUrl` and `thumbnailUrl` are empty. `price` and `currency` are filled only when Google shows a price.

### How much does it cost to run a reverse image search with Google Lens?

You pay a small fee per run plus a fee per match returned. Images with no matches add nothing.

| Event | Free | Bronze | Silver | Gold and above |
| --- | --- | --- | --- | --- |
| Run started | $0.01 once per run | $0.01 | $0.01 | $0.01 |
| Match returned | $0.000648 | $0.000648 | $0.0005832 | $0.0005184 |

Searching 100 images for 10 visual matches each (1,000 matches) costs about $0.66 on the Bronze plan, and 100 matches cost about $0.075. Use **Maximum matches per image** to control the cost.

### How to use it

1. Add your image links under **Image URLs**.
2. Choose **Visual matches**, **Exact matches** or both.
3. Set **Maximum matches per image**, then click **Start**.

### API

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~google-lens-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"imageUrls":["https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"],"matchTypes":["visual"],"maxMatchesPerImage":10}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("automation-lab/google-lens-scraper").call(run_input={
    "imageUrls": ["https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"],
    "matchTypes": ["visual", "exact"],
    "maxMatchesPerImage": 10,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["matchType"], row["rank"], row["pageUrl"], row.get("priceText"))
```

### Use with MCP and AI agents

Add the Apify MCP endpoint to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/google-lens-scraper"
```

Use the same remote-server configuration in **Claude Desktop**, **Cursor**, or **VS Code**:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/google-lens-scraper"
    }
  }
}
```

In Claude Desktop, Cursor, and VS Code, open the application's MCP settings and add the `apify` server shown above.

Example prompts:

- "Find stores that sell the product in this photo and list their prices."
- "Where else on the web does this image appear?"
- "Check these 20 catalog photos for exact copies on other sites."

### Tips

- Use clear product photos on a plain background for the best shopping matches.
- Set `country` to your market so prices and stores are local.
- The link must return the image file itself, not a web page that shows it.

### Is it legal to use this?

This Actor sends your images to Google Lens and does not log in to an account. It returns public search results. Every image you submit is sent to Google for analysis, so do not submit images you are not allowed to share. You are responsible for how you use the results, including copyright and privacy rules such as GDPR, especially for images that show people. Consult a lawyer if you are unsure.

This Actor is not affiliated with, endorsed by or sponsored by Google. Google Lens is a trademark of Google LLC and is named only to describe the data source.

Input images and results stay in your Apify storage under your account's retention settings. Failed runs send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip error-tracking service so we can repair problems. These reports never include images or tokens and are retained for 30 days.

### FAQ

**Why did an image return no rows?** Google Lens found no matches for it. That image adds nothing to the price.

**Why was an image skipped?** Its link did not return an image file. Some hosts, such as Wikimedia, refuse unusual thumbnail sizes; use the original file link. The run's status message names the skipped image.

**How many matches can I get?** Google usually shows up to about 60 visual matches per image. Exact matches depend on how often the image is reused.

**Why do exact matches have no thumbnail?** Google does not show one on that tab. Each exact match still links to the page that contains the image.

### Related Actors

- [Google Lens OCR](https://apify.com/automation-lab/google-lens-visual-matches-and-detected-text) to read text in images.
- [Google Images Scraper](https://apify.com/automation-lab/google-images-scraper) for image search by keyword.
- [Google Search Scraper](https://apify.com/automation-lab/google-search-scraper) for regular search results.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/google-lens-scraper/changelog.md

# Actor input Schema

## `imageUrls` (type: `array`):

Direct links to the images to search, such as product photos from your catalog. JPEG, PNG, WebP, GIF and BMP up to 20 MB. Up to 500 images per run. To search a file from your computer, upload it to a key-value store or any public host and paste its link.

## `matchTypes` (type: `array`):

"Visual" returns pages with similar-looking images (Google Lens "Visual matches" tab), with product prices and stock text when Google shows them. "Exact" returns pages that contain this same image (the "Exact matches" tab), with the image size and date.

## `maxMatchesPerImage` (type: `integer`):

The most matches to return for each image and each match type. Google usually shows up to about 60 visual matches.

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

Two-letter country code Google uses for local results and prices, such as "us", "gb" or "de".

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

Language code for titles and the Google interface, such as "en", "de" or "pt-br".

## Actor input object example

```json
{
  "imageUrls": [
    "https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"
  ],
  "matchTypes": [
    "visual",
    "exact"
  ],
  "maxMatchesPerImage": 20,
  "country": "us",
  "language": "en"
}
```

# Actor output Schema

## `overview` (type: `string`):

All matches with page link, title, site, price, stock text and matching image.

# 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 = {
    "imageUrls": [
        "https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"
    ],
    "matchTypes": [
        "visual",
        "exact"
    ],
    "maxMatchesPerImage": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-lens-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 = {
    "imageUrls": ["https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"],
    "matchTypes": [
        "visual",
        "exact",
    ],
    "maxMatchesPerImage": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-lens-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 '{
  "imageUrls": [
    "https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=600"
  ],
  "matchTypes": [
    "visual",
    "exact"
  ],
  "maxMatchesPerImage": 20
}' |
apify call automation-lab/google-lens-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/google-lens-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/XE3MGCJwzkbxaSvSL/builds/ypL0jYXlpqJaQa1X3/openapi.json
