# Google Lens Reverse Image Search (`steady-scrape/google-lens-search`) Actor

Find visual matches, product listings and pages that use a photo. Paste an image URL and get Google Lens results as JSON. Pay per image with matches; empty searches are free.

- **URL**: https://apify.com/steady-scrape/google-lens-search.md
- **Developed by:** [SteadyScrape](https://apify.com/steady-scrape) (community)
- **Categories:** AI, E-commerce, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 image with matches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 API

**Who it's for:** ecommerce, brand-protection, catalog and research teams who need to see where a photo appears on the web, plus developers and AI agents that cannot run visual search natively.

**What you get:** for each public image URL, Google Lens visual matches and pages that use the image, as clean JSON. Each result includes title, page URL, domain, thumbnail, rank, and (when Google shows them) a product price and the keyword Google associated with the image. You get metadata and links only: image files are not downloaded or rehosted.

**Price:** $0.004 per image that returns at least one match or page, plus $0.003 once per run that has such an image. An image that finds nothing is free, and so are failed or timed-out searches. 1 image with matches = $0.007. 10 images with matches in one run = $0.043.

Made by **SteadyScrape (steady-scrape)**.

### What you can do with it

1. **Find where a product photo is used.** Paste a catalog image and see marketplaces, blogs and shops that show the same or a similar picture.
2. **Brand and counterfeit monitoring.** Check whether a logo or product shot appears on unexpected sites.
3. **Visual research for agents.** Give an AI agent a picture it cannot see on its own, and get structured Lens results back.
4. **Product matching.** Use associated keywords and priced pages to identify what an unlabeled photo is.
5. **Pair with Google Images.** Keyword search finds images; this Actor starts from an image and finds the web around it.

### Input

A list of public image URLs that share one country, language and queue:

```json
{
  "imageUrls": [
    "https://dataforseo.com/wp-content/uploads/2016/11/data_for_seo_light_429.png"
  ],
  "country": "us",
  "language": "en",
  "priority": true,
  "depth": 100
}
```

Advanced form: a different country, language or queue for each image. You can combine both forms, up to 10 images per run.

```json
{
  "queries": [
    { "imageUrl": "https://example.com/mug.jpg", "country": "us", "language": "en", "priority": true },
    { "imageUrl": "https://example.com/tasse.jpg", "country": "de", "language": "de", "priority": false }
  ]
}
```

- **priority** (default on): faster queue. Turn it off for the standard queue, which is slower.
- **depth**: results kept per image, from 1 to 100 (visual matches first, then pages).
- **dryRun**: test mode with labeled sample rows. No search is run and nothing is charged.
- Country codes are ISO two-letter codes (`uk` is accepted as `gb`). Chinese must be `zh-CN` or `zh-TW`.
- Only public `http` or `https` image URLs are accepted. URLs with credentials or access tokens are rejected.

### Output

Each image gets one status row (`recordType: "queryStatus"`), one row per visual match (`visualMatch`), and one row per page (`page`).

| Field | Meaning |
| --- | --- |
| `rank`, `rankAbsolute` | Position in the Lens results |
| `title`, `altText` | Result title and image alt text |
| `imageUrl`, `thumbnailUrl` | Match image and thumbnail, when present |
| `pageUrl`, `pageDomain` | Page that shows a visual match |
| `url`, `domain`, `sourceName`, `description` | Page results (sites using the image) |
| `priceCurrent`, `priceCurrency`, `priceDisplayed` | Price Google showed on a page, when present |
| `associatedKeyword` | Keyword Google associated with the image (status rows) |
| `lensUrl` | Status rows only: the Google Lens page for that image |
| `refinements` | Status rows only: refinement labels Google showed |
| `queryStatus` | `success`, `partial`, `empty`, `timeout`, `failed`, `provider_error`, `malformed_response`, `unsupported_locale`, `not_run`, or `invalid_input` |
| `matchCount`, `pageCount`, `duplicatesDropped` | Status rows only: counts for that image |

`partial` means the search returned results, but a few were incomplete and were left out. The `OUTPUT` record summarizes every image and its status.

### Queues

This search has no instant live mode. Priority is the default and usually finishes in about a minute. The standard queue is slower, often a few minutes. A search that is still running when the wait limit is reached is marked `timeout` and is not charged.

### Pricing

Pay per event:

- $0.004 per image with at least one visual match or page (`successful-search`)
- $0.003 once per run that has such an image (`run-with-success`)
- Empty, failed, timed-out and refused searches are free

Worked examples: 1 photo with matches costs $0.007. 10 product photos that all have matches cost $0.043. 1,000 photos with matches (100 runs of 10) cost $4.30. A run that finds nothing costs $0.

The default maximum charge per run is $0.50, more than a full 10-image run ($0.043). If you set a lower maximum charge per run (`maxTotalChargeUsd`), the Actor stops before starting a search that would go over that limit, and skipped images are free.

### Compared with other options

- **Manual Google Lens in a browser:** fine for one photo, but there is no export, no schedule and no API. This Actor returns the same kind of results as structured JSON.
- **Per-row pricing:** some tools bill every visual match. Here you pay once per image that finds anything, so a photo with 100 matches costs the same as one with 5.
- **Start fees:** there is no per-run start fee. A run that finds nothing is free.

### FAQ

**Can I upload a file?** Not in this version. Host the image at a public URL first.

**Does it download my image?** No. The URL is sent to the search service. This Actor does not store or rehost image files.

**Why was a search slow or timed out?** The standard queue can take several minutes. Use `priority: true` (the default) when you need a faster answer.

**What images are allowed?** Public product, logo, artwork and similar images. Do not submit personal photos of private individuals, identity documents, or private files.

### Integrations

Works with the Apify API, schedules, and Make/Zapier/n8n. AI agents can call it through the [Apify MCP server](https://mcp.apify.com). It is part of the **SteadyScrape Research MCP bundle**, together with Google Images, Google News, PDF Text, Screenshots and Bulk Downloader. Each tool is billed at its own Actor price; the bundle adds no extra fee.

```json
{
  "mcpServers": {
    "steadyscrape-research": {
      "url": "https://mcp.apify.com/?tools=steady-scrape/google-images-api,steady-scrape/google-lens-search,steady-scrape/google-news-monitor,steady-scrape/pdf-text-markdown,steady-scrape/website-screenshot-evidence-packs,steady-scrape/bulk-file-downloader"
    }
  }
}
```

Sign in to Apify with OAuth on first connect.

### More from SteadyScrape

- [Bing, Yahoo, Baidu, Naver & Seznam Search Results API](https://apify.com/steady-scrape/multi-engine-serp-api): organic results from five non-Google search engines in one schema.
- [Google Images API](https://apify.com/steady-scrape/google-images-api) — keyword to image results
- [Google News Monitor](https://apify.com/steady-scrape/google-news-monitor) — brand and topic news, only new articles
- [PDF to Text / Markdown](https://apify.com/steady-scrape/pdf-text-markdown) — digital PDFs
- [Scanned PDF OCR](https://apify.com/steady-scrape/pdf-ocr-scanned) — scanned pages
- [Website Screenshot Evidence Packs](https://apify.com/steady-scrape/website-screenshot-evidence-packs)
- [Bulk Image and File Downloader](https://apify.com/steady-scrape/bulk-file-downloader)

# Actor input Schema

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

Public http(s) image URLs, one per line. Each uses the country, language and queue below. Up to 10 images per run, counting any advanced queries.

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

ISO 3166-1 alpha-2 country code for the image list, for example us. The code uk is accepted as gb.

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

Language code for the image list, for example en. Chinese must be zh-CN or zh-TW.

## `priority` (type: `boolean`):

When on (default), uses the faster priority queue. When off, uses the standard queue, which is slower.

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

Optional. Up to 10 searches, each with its own image URL, country, language and queue. Use this instead of, or together with, the image URL list.

## `depth` (type: `integer`):

Maximum results kept for each image, counting visual matches first and then pages. The hard cap is 100, which is a single result page.

## `dryRun` (type: `boolean`):

Test mode: return labeled sample rows without running a search. Nothing is charged.

## Actor input object example

```json
{
  "imageUrls": [
    "https://dataforseo.com/wp-content/uploads/2016/11/data_for_seo_light_429.png"
  ],
  "country": "us",
  "language": "en",
  "priority": true,
  "depth": 100,
  "dryRun": false
}
```

# Actor output Schema

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

Dataset rows for visual matches, pages, and query statuses.

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

Run summary stored in the default key-value store.

# 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://dataforseo.com/wp-content/uploads/2016/11/data_for_seo_light_429.png"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steady-scrape/google-lens-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://dataforseo.com/wp-content/uploads/2016/11/data_for_seo_light_429.png"] }

# Run the Actor and wait for it to finish
run = client.actor("steady-scrape/google-lens-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://dataforseo.com/wp-content/uploads/2016/11/data_for_seo_light_429.png"
  ]
}' |
apify call steady-scrape/google-lens-search --silent --output-dataset

```

## MCP server setup

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