# Google Lens Reverse Image Search — Visual Matches, No Login (`steadyfetch/google-lens-reverse-image-search`) Actor

Google Lens reverse image search, per image: paste image links and get one row per visual match (page, title, site, the original picture and its size), plus the pages about the picture — or every page carrying that exact image. One flat row per result. No login, no API key, no start-up setup.

- **URL**: https://apify.com/steadyfetch/google-lens-reverse-image-search.md
- **Developed by:** [Steadyfetch Team](https://apify.com/steadyfetch) (community)
- **Categories:** AI, E-commerce, SEO tools
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 image searches

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 — Visual Matches, No Login

**Paste links to pictures and get Google Lens's answer for each one as flat rows: every visual match (the page, its title, the site, the original picture and its size), the pages about the picture and its short videos — or every page carrying that exact picture. Priced per image searched, from $4.50 per 1,000 image searches. No login, no API key.**

Marketers, brand-protection and e-commerce teams use reverse image search to find where a picture is used, who else sells a product photo, which sites copied an image without attribution, and where a picture first came from. This actor runs Google Lens on your image links and returns one row per result, so a list of product photos or campaign images becomes one table you can filter, sort and export.

**Using an AI agent?** Pin this actor in Apify's MCP server with one link: `https://mcp.apify.com?tools=steadyfetch/google-lens-reverse-image-search`

- **Actor id:** `steadyfetch/google-lens-reverse-image-search`
- **Input:** `{ "imageUrls": ["https://example.com/product-photo.jpg"], "searchType": "visual" }`
- **Cap the bill:** set `maxTotalChargeUsd` on the run (a run option, not Actor input), e.g. `0.50` — the run searches only the images that can pay.
- **Price:** $0.0045 per image searched at Gold ($0.006 on the Apify free plan), no start fee. Full table below.
- **How often it changes:** Google Lens finds new pages carrying a picture every day. A weekly re-search of the same image, with results you already received marked `seenBefore`, shows what is new.

*Unofficial. Not affiliated with, endorsed by, or sponsored by Google.*

This actor finds where an **image** appears on the web. It is not a people-search tool: do not use it to identify a person from a photo.

### What you get

One flat row per result (`rowType: "result"`), in the order Google Lens shows them:

| Column | What it holds |
|---|---|
| `imageUrl` · `imageIndex` | the image link you gave, and its place in your list |
| `resultType` | `visual_match` (a picture like yours), `page` (a page about the picture), `video` (a short video), or `exact_match` (a page carrying your exact picture, exact mode) |
| `position` | its rank within its type |
| `title` · `pageUrl` | the page's title and link |
| `sourceName` · `sourceDomain` | the site's name and domain |
| `originalImageUrl` · `originalImageWidth` · `originalImageHeight` | the matching picture's own address and its size in pixels (visual matches); in exact mode, the size the picture is shown at on that page |
| `thumbnailUrl` | Google's small preview of the match |
| `description` · `price` · `currency` | the page's snippet, and a price where the page is a shop listing |
| `seenBefore` | `true` when this actor already delivered this result to your account for the same image link |

Then one **image row** per searched image (`rowType: "image"`) with its counts — results found and delivered, visual matches, pages, videos, exact matches — and the image's one search fee. An image Google Lens found nothing for gets its image row too, saying "Google Lens found no matches for this image."

Every row also carries `charged`, `chargedEvents`, `status` and `statusReason`, so you can reconcile your bill from the dataset itself.

### How to use it

1. Put your picture links in **Image links** — one per line, the address of the picture itself (`https://…/photo.jpg`), not of the page it sits on. Up to 100 per run.
2. Pick the **Search type**: `visual` (pictures like this one, about 60 a picture, plus pages and videos) or `exact` (every page carrying this exact picture, up to about 400). Google Lens's own words are read too, and the first row says how: `search`, `similar`, `products`, `shopping`, `all`, `image`, `reverse image` or `lens` run visual; `exact match`, `same image`, `identical`, `find image source` or `source` run exact. Lens's `text`, `translate`, `about this image` and `homework` modes are not image searches, so they are refused on each image's row and nothing is charged.
3. Press Start — or schedule it weekly.

Optional: **Max results per image** (the fee is the same whatever it is set to), **Only results I have not received**, **Max run seconds**.

Refused before any search, and never charged: an entry that is not a public link to a picture, a pasted file (`data:` link), a link that opens a web page, a link with nothing at the address, and a picture larger than **7 MB**. Each gets its own row saying why.

### Pictures Google Lens cannot open

Google Lens fetches each picture from its own address. Some sites refuse it, mostly for large pictures. When Lens answers nothing for a picture this actor can open, the run copies the picture into **your run's own storage** (in your Apify account), sends Lens a private signed link to that copy, and deletes the copy once Lens has answered. The image row and its results say when this happened (`route: "copy"`; otherwise `route: "direct"`). The second search is on us: one image, one fee. The Standby endpoint makes no copy; it answers an uncharged note and a run re-sends the picture.

### Only the new results

This actor keeps a small record per image link in a store named `google-lens-account` in **your** Apify account: the ids of the results it delivered to you, nothing else. Results you already received are marked `seenBefore: true`; turn on **Only results I have not received** to leave them out. Every search is still a fresh Google Lens search and is charged as one.

### Pricing

Pay per image searched, all-inclusive (no platform usage on top), no start fee:

| Event | Apify Free plan | Bronze | Silver | Gold and up |
|---|---|---|---|---|
| Image search (one image Google Lens answered, matches or none) | $0.006 | $0.0055 | $0.005 | $0.0045 |

An image with no match is still charged, because it was searched. Never charged: an image refused before the search, one Lens did not answer in time, one it returned nothing for that could not be re-sent, and the bare-Start sample.

Examples at Gold: 1 image = $0.0045. 10 images = $0.045. 100 images in exact mode = $0.45, however many pages each one returns.

### Good to know

- **A time limit ends the searching, never the delivering**: images already searched are delivered, and the receipt says which limit stopped the run.
- **Free plan:** on the Apify free plan a run searches five images per 24 hours; the row says when it resets. Paid plans have no daily allowance.
- **Standby endpoint:** one image per HTTP request (`GET /?imageUrl=https://example.com/photo.jpg`), at the same price per image. It keeps **no** account memory and makes no copy of a picture.
- **Results drift:** Google Lens is read as it answers in the United States in English, and on a famous picture it still mixes pages in other languages.
- **Bare Start:** with no image set, the run searches one public-domain painting as a sample and charges nothing.
- **Honest rows:** `not_found` (nothing at the address), `no_data` (Lens returned nothing and the picture could not be re-sent), `try_again` (no answer in time — a re-run fixes it). None is charged.
- The receipt is the last row (`run_summary`) and the run's `OUTPUT` record.

### Support

Questions, an image that returns something odd, or a column you need: open an issue on the Issues tab and it will be looked at.

If it earned its keep, a rating helps other buyers find it, and saving the actor keeps it one click away.

# Changelog

This Actor's version history is a separate document: https://apify.com/steadyfetch/google-lens-reverse-image-search/changelog.md

# Actor input Schema

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

One public link to a picture per entry (JPG, PNG, WEBP, GIF), like https://example.com/photo.jpg — the address of the picture itself, not of the page it sits on. Up to 100 per run. Each link is checked first, with nothing charged: one that opens a web page, has nothing at the address or is larger than 7 MB is refused before any search, and nothing is charged for it. An image with no match is still charged, because it was searched.

## `searchType` (type: `string`):

visual (the default): Google Lens's visual matches (about 60 a picture), the pages about it and its short videos. exact: the pages that carry this exact picture (up to about 400), each with its shown size. Lens's words work too (the first row says so): search, similar, products, shopping, image or lens run visual; exact match, same image, identical or source run exact. Its text, translate and homework modes are not image searches; any other value is refused on every image's row, never guessed.

## `maxResultsPerImage` (type: `integer`):

The most result rows to deliver per image, in the order Google Lens shows them. The image search fee is the same whatever this is set to.

## `onlyNewResults` (type: `boolean`):

Off (the default): every result is delivered, and a result this actor already delivered to your account for the same image link is marked seenBefore: true. On: those results are left out. This actor remembers what it delivered in a store in YOUR Apify account. Every search is still a fresh, charged search.

## `maxRunSeconds` (type: `integer`):

Optional. Stop searching new images after this many seconds; images already searched are always delivered. A search usually takes 10 to 60 seconds; up to 8 run at once.

## Actor input object example

```json
{
  "imageUrls": [
    "https://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg/500px-Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg"
  ],
  "searchType": "visual",
  "maxResultsPerImage": 500,
  "onlyNewResults": false
}
```

# Actor output Schema

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

One flat row per result Google Lens gave for a searched image: resultType (visual_match, page, video, or exact_match in exact mode), position, title, pageUrl, sourceName, sourceDomain, description, thumbnailUrl, originalImageUrl with its width and height, and the image link it was found for. Result rows say charged: false — each searched image is charged ONE `image` on its own image row, which carries the image's counts (results found and delivered, visual matches, pages, videos, exact matches). An image Google Lens found no matches for still gets its image row, charged one `image`, saying so. Each row's `route` says whether the picture was searched from its own address (`direct`) or from a private copy in your run's storage (`copy`). Every row carries `charged`, `chargedEvents` and `status`, so the invoice reconciles from the dataset itself.

## `misses` (type: `string`):

One uncharged row for each image that was not searched or returned nothing that could be charged: `input_error` (an entry that is not a public image link, a link that opens a web page, a picture larger than 7 MB, or a search type that names nothing — the row names the field), `not_found` (nothing at the address, or its site does not exist), `no_data` (Google Lens returned nothing and the picture could not be re-sent), `try_again` (the answer did not arrive in time; a re-run is the fix), `skipped_budget` / `skipped_deadline` (your maximum charge or the run clock stopped it first) and `skipped.free_plan_allowance` (Apify free plan only: the plan's daily allowance on this actor; the row names the reset time).

## `summary` (type: `string`):

The run's receipt: images searched, what was asked for, images with no match, result rows, results you already had, the charged events and what stopped the run. Uncharged.

# 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://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg/500px-Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyfetch/google-lens-reverse-image-search").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://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg/500px-Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg"] }

# Run the Actor and wait for it to finish
run = client.actor("steadyfetch/google-lens-reverse-image-search").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://upload.wikimedia.org/wikipedia/commons/thumb/e/ea/Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg/500px-Van_Gogh_-_Starry_Night_-_Google_Art_Project.jpg"
  ]
}' |
apify call steadyfetch/google-lens-reverse-image-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steadyfetch/google-lens-reverse-image-search"
        }
    }
}
```

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/f3ZbvIW2wPBCagCaq/builds/3XQoazlWfSObcJNvm/openapi.json