# Google Lens | AI Mode | Reverse image search | Translation+OCR (`borderline/google-lens`) Actor

Google Lens | Reverse image search | AI Mode🌟 Seamlessly identify text, translate in real time 🌐, recognize and classify objects 🎁, reverse search images 🔍, and extract detailed structured data 📚. It’s fast, reliable, and affordable—your essential tool for all visual intelligence needs! 🚀

- **URL**: https://apify.com/borderline/google-lens.md
- **Developed by:** [borderline](https://apify.com/borderline) (community)
- **Categories:** AI, SEO tools, E-commerce
- **Features:** Limited permissions
- **Stats:** 2,368 total users, 253 monthly users, 99.9% runs succeeded, 12 bookmarks
- **User rating**: 3.91 out of 5 stars

## Pricing

from $6.50 / 1,000 🤖 ai analyses

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 Actor

Welcome to the **Google Lens Actor**! This unofficial Google Lens API empowers you to analyze images programmatically, just like Google Lens does, but with added flexibility. Whether you're identifying text, recognizing objects, performing reverse image searches, or getting AI-powered insights, this Actor has got you covered!

> **🤝 Contribute:** Feel free to open issues or pull requests to suggest new features or report bugs!

***

### ✨ What Does the Google Lens Actor Do?

This Actor allows you to process images in multiple powerful ways, delivering programmatic access to:

- 🔍 **OCR and Text Recognition**: Extract text from images with high accuracy
- 🌐 **Text Translation**: Translate extracted text into any supported language
- 🖼️ **Reverse Image Search**: Discover similar images and their sources
- 🎯 **Exact Match Search**: Find exact matches of images across the web
- 👁️ **Visual Match Search**: Find visually similar images
- 🛍️ **Product Search**: Identify and find products in images
- 📚 **Homework Help**: Get educational assistance for images with questions or problems
- 🤖 **AI Mode**: Ask questions about images and get AI-powered answers

***

### 💡 Why Use the Google Lens Actor?

- 🧠 **Bootstrap AI Training**: Build robust AI models with curated datasets
- 🛍️ **Find Similar Products**: Enhance shopping experiences with visual matches
- 🔦 **Detect Web Content**: Discover hidden or related content online
- 📖 **Extract Text**: Convert images to searchable, translatable text
- 🤖 **AI-Powered Insights**: Get intelligent answers about image content

***

### 🛠️ How to Use the Google Lens Actor

#### Step 1: Prepare Your Input

Provide the Actor with one or more images and select which search types you want to perform. You can supply images in three ways — use any combination in the same run:

- **`imageUrls`** — image URLs from blogs, social media, e-commerce sites, or anywhere on the web.
- **`imagesBase64`** — images encoded directly as base64 strings, for when you don't have a public URL (local files, generated images, private assets).
- **`imageKvsRecords`** — images stored in an Apify [Key-Value Store](https://docs.apify.com/storage/key-value-store), referenced by record key. Best for large or private images you've already uploaded to a store.

> **Why not a direct file upload?** Apify Actors receive their input as JSON, so they can't accept a raw multipart binary file the way a traditional HTTP API can. The three options above cover the same ground: link a hosted image (`imageUrls`), inline the bytes as base64 (`imagesBase64`), or upload the raw bytes to Apify storage and reference them (`imageKvsRecords`). The last one is the closest to passing a file as bytes — no encoding needed. See [Integrating from Python](#integrating-from-python) below for a copy-paste example.

**Input Example:**

```json
{
    "searchTypes": ["all", "ai-mode", "translate-ocr"],
    "imageUrls": [
        { "url": "https://example.com/image1.jpg" },
        { "url": "https://example.com/image2.png" }
    ],
    "aiModeQuestions": [
        "What is the main color in this image?",
        "What objects can you identify?"
    ],
    "translateLanguage": "fr",
    "language": "en"
}
```

**Input Parameters:**

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTypes` | `array` | Yes | Array of search modes to perform. Available options: `all`, `ai-mode`, `ocr`, `translate-ocr`, `exact-match`, `visual-match`, `products`, `homework` |
| `imageUrls` | `array` | Conditional | List of image URLs to process. Provide at least one of `imageUrls` or `imagesBase64` |
| `imagesBase64` | `array` | Conditional | List of images encoded as base64 strings. Accepts raw base64 or a `data:<mime>;base64,...` data URI. Provide at least one of `imageUrls` or `imagesBase64` |
| `imageKvsRecords` | `array` | Conditional | Images to read from an Apify Key-Value Store. Use `{ "storeId": "<store>" }` (no `key`) to process **every** image in a store, or `{ "key": "<record-key>", "storeId": "<store>" }` for specific files. Omit `storeId` to use this run's default store. Provide at least one of `imageUrls`, `imagesBase64`, or `imageKvsRecords` |
| `aiModeQuestions` | `array` | Conditional | Questions to ask about the images (required if `ai-mode` is selected) |
| `translateLanguage` | `string` | No | Target language code for translation (default: "en"). Used with `translate-ocr` mode |
| `language` | `string` | No | Language for search results (default: "en") |

**Available Search Types:**

- `all` - All search results from Google Lens
- `ai-mode` - AI-powered answers to questions about the image
- `ocr` - Extract text from images
- `translate-ocr` - Extract and translate text from images
- `exact-match` - Find exact matches of the image
- `visual-match` - Find visually similar images
- `products` - Search for products in the image
- `homework` - Get educational help for homework questions

***

#### Step 1b: Size the run for how many images you send

Each image is a real Google Lens session in a real browser, so a run's length grows with
`number of images × number of search types`. Two settings in **Run options** decide whether a
big batch finishes:

| Images × search types | Suggested **Memory** | Suggested **Timeout** |
|---|---|---|
| up to ~10 | 4 GB | default |
| 10 – 100 | 8 GB | 1–3 hours |
| more than 100 | 8 GB, or split into several runs | several hours |

Memory is picked for you from your input, so most runs need no change. On Apify, memory also
buys CPU, which is what lets the Actor drive several browsers at once.

If a run cannot fit in its timeout, the Actor says so in the log **and** in the
**⚠️ Errors and skipped images** view before it starts working, with the timeout to aim for.
Results are written to the dataset as they arrive, so a run that is stopped early still keeps
everything it already found.

***

#### Step 2: Review the Output

After processing, the Actor generates structured data that can be downloaded in various formats, such as JSON, CSV, Excel, or HTML.

##### Dataset Views

The Actor provides organized dataset views for easy access to your results. Each search type has its own view in the Apify console:

- **🔎 Web search results** - pages Google Lens found for your image, from the Lens "All" tab. One row per page. This tab is that tab only, not a combination of the others.
- **🎯 Exact image matches** - pages republishing the very same image, with the size of the copy hosted there
- **👁️ Visually similar images** - images that look like yours without being the same file, with the page hosting each one
- **🛍️ Shopping results** - products matched to your image, with price, store and rating
- **📝 Text read from the image** - the text Lens read in your image, one row per image
- **🌐 Text read and translated** - that text next to its translation
- **🤖 AI answers about the image** - each question you asked and the answer given
- **📚 Homework help** - explanations and study resources for the exercise in your image
- **⚠️ Errors and skipped images** - images no search type could process, and run-level failures

Every row carries a **Row type** column naming the search type it belongs to: one dataset holds the
items of every search type, so each tab also lists the rows belonging to the others.

Access these views in the **Storage** tab of your Actor run on the Apify console.

***

### 🎯 Output Examples

#### Web search results

Pages found for your image. Each item is wrapped under its search type, and carries a `searchType` label:

```json
{
  "searchType": "all",
  "all": {
    "inputUrl": "https://example.com/sneaker.jpg",
    "results": [
      {
        "search": {
          "title": "Vans Old Skool - Wikipedia",
          "href": "https://en.wikipedia.org/wiki/Vans_Old_Skool",
          "description": "The Old Skool is a skate shoe."
        },
        "inputUrl": "https://example.com/sneaker.jpg"
      }
    ]
  }
}
```

#### Visually similar images

Images that look like yours, each with the page hosting it. When the look-alike is a listing, the
store and the price come with it:

```json
{
  "searchType": "visual-match",
  "visual-match": {
    "inputUrl": "https://example.com/sneaker.jpg",
    "results": [
      {
        "position": 1,
        "title": "VANS Old Skool Blue Canvas/Suede Lace Up Low Top Skate Shoes",
        "link": "https://www.ebay.com/itm/403568610810",
        "source": "eBay",
        "price": "$26",
        "thumbnail": "data:image/jpeg;base64,…",
        "sourceIcon": "data:image/png;base64,…",
        "inputUrl": "https://example.com/sneaker.jpg"
      }
    ]
  }
}
```

#### OCR - Text Extraction

One row per image, holding the whole text Lens read. Word-by-word positions and the image Lens
rendered are kept in the same item:

```json
{
  "searchType": "ocr",
  "ocr": {
    "inputUrl": "https://example.com/nutrition-label.png",
    "originalExtractedText": "Nutrition Facts 8 servings per container Serving size 2/3 cup (55g)",
    "originalImage": {
      "words": [
        {
          "text": "Nutrition",
          "top": "12.5px",
          "left": "8px",
          "width": "96.3px",
          "height": "21px",
          "rotation": 0
        }
      ],
      "img": "data:image/png;base64,…",
      "width": 343,
      "height": 416
    },
    "results": [{ "inputUrl": "https://example.com/nutrition-label.png" }]
  }
}
```

#### Translate OCR - Text Translation

Extract and translate text from images:

```json
{
  "searchType": "translate-ocr",
  "translate-ocr": {
    "originalExtractedText": "GOOD VIBES ONLY",
    "extractedTranslatedText": "BONNES VIBRATIONS",
    "originalImage": {
      "words": [
        {
          "text": "GOOD",
          "top": "412.417px",
          "left": "144.583px",
          "width": "747.583px",
          "height": "177.983px",
          "rotation": 0
        },
        {
          "text": "VIBES",
          "top": "658.55px",
          "left": "115.15px",
          "width": "808.883px",
          "height": "183.917px",
          "rotation": 0
        }
      ]
    },
    "translatedImage": {
      "words": [
        {
          "text": "BONNES",
          "top": "412.417px",
          "left": "144.583px",
          "width": "747.583px",
          "height": "177.983px",
          "rotation": 0
        },
        {
          "text": "VIBRATIONS",
          "top": "658.55px",
          "left": "115.15px",
          "width": "808.883px",
          "height": "183.917px",
          "rotation": 0
        }
      ]
    }
  }
}
```

#### AI Mode

Get AI-powered answers about your images:

```json
{
  "ai-mode": {
    "results": [
      {
        "question": "What is the main color in this image?",
        "answer": "The main color in this image is blue, with various shades creating a calming atmosphere."
      },
      {
        "question": "What objects can you identify?",
        "answer": "I can identify a laptop, a coffee cup, a notebook, and a pen on a wooden desk."
      }
    ]
  }
}
```

#### Products

Find and identify products in images:

```json
{
  "products": {
    "results": [
      {
        "title": "Yogi Board Game",
        "price": "$24.99",
        "vendor": "Amazon",
        "link": "https://www.amazon.com/...",
        "thumbnail": "https://..."
      }
    ]
  }
}
```

***

### 🔦 Real-World Use Cases

- 📊 **Data Analysis**: Extract text and data from images for research and reporting
- 🎨 **Creative Inspiration**: Use visual matches to fuel your designs
- 🛍️ **E-commerce**: Identify and find similar products from images
- 🧠 **AI Training**: Build robust datasets for machine learning models
- 📚 **Education**: Get help with homework and learning materials
- 🌐 **Content Discovery**: Find the source and context of images
- 🤖 **Intelligent Image Analysis**: Ask questions and get AI-powered insights about any image

***

### 🏁 Ready to Start?

1. Create a free Apify account at [apify.com](https://apify.com)
2. Find the Google Lens Actor in the Apify Store
3. Configure your input:
   - Add image URLs (`imageUrls`) and/or base64 images (`imagesBase64`)
   - Select search types (`all`, `ai-mode`, `translate-ocr`, etc.)
   - Add optional parameters like AI questions or translation language
4. Click "Start" to process your images
5. View results in the **Storage** tab using the convenient dataset views
6. Download results in your preferred format (JSON, CSV, Excel, HTML)

***

### 📖 Advanced Features

#### Multiple Search Types

Run multiple search types simultaneously to get comprehensive image analysis:

```json
{
    "searchTypes": ["all", "ocr", "products", "ai-mode"],
    "imageUrls": [{ "url": "https://example.com/product.jpg" }],
    "aiModeQuestions": ["What product is this?", "What is its condition?"]
}
```

#### Language Support

The Actor supports 100+ languages for both search results and text translation. Specify your preferred language:

```json
{
    "searchTypes": ["translate-ocr", "all"],
    "imageUrls": [{ "url": "https://example.com/image.jpg" }],
    "translateLanguage": "fr",
    "language": "fr"
}
```

#### Base64 Image Input

When you don't have a public URL for an image (local files, generated images, private assets), send it directly as base64 via `imagesBase64`. The Actor decodes each string and sends it straight to Google Lens — no hosting required. Both raw base64 and data URIs (`data:image/png;base64,...`) are accepted, and you can mix `imagesBase64` with `imageUrls` in the same run.

```json
{
    "searchTypes": ["all", "ai-mode"],
    "imagesBase64": [
        "iVBORw0KGgoAAAANSUhEUgAAAB4AAAAe...",
        "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..."
    ],
    "aiModeQuestions": ["What is the main subject of this image?"]
}
```

Each base64 image appears in the results under the identifier `base64:<index>` (`base64:0` for the first, `base64:1` for the second, and so on). If one base64 string is invalid, it is reported individually in the **Global Errors** view and the run continues for the remaining images.

> **Note:** Base64 payloads are part of the Actor input, which is subject to Apify's input size limit. For very large images, prefer `imageUrls`.

#### Using images from a Key-Value Store

Already have images stored on Apify (too big for base64, or private)? Point the Actor at a [Key-Value Store](https://docs.apify.com/storage/key-value-store) and it reads them straight from there. You can process **one whole store at once** or **pick specific files**.

##### Step 1 — Put your images in a Key-Value Store

Pick whichever is easiest:

- **In the Apify Console:** go to **Storage** → **Key-value stores** → open (or create) a store → **Upload** your image files. Each file becomes a *record*, and its filename is its *key*.
- **With the API:** `PUT https://api.apify.com/v2/key-value-stores/{STORE_ID}/records/{KEY}` with the image bytes and the right `Content-Type` header (e.g. `image/png`, `image/jpeg`).
- **From another Actor** that writes image records into a store.

##### Step 2 — Find your store's name or ID

Open the store in the Console — the **name** and **Store ID** are shown at the top. Either works in the input below. A named store looks like `username~store-name` (note the `~`); a Store ID is a short code like `aBc123XyZ`.

##### Step 3 — Reference the images in your input

**Option A — the whole store (easiest).** Give a `storeId` and *no* `key`, and every image in that store is processed:

```json
{
    "searchTypes": ["all", "ai-mode"],
    "imageKvsRecords": [
        { "storeId": "my-image-store" }
    ]
}
```

**Option B — specific files.** Give the `key` of each record you want:

```json
{
    "searchTypes": ["all", "ai-mode"],
    "imageKvsRecords": [
        { "key": "product-photo", "storeId": "my-image-store" },
        { "key": "screenshot-01", "storeId": "my-image-store" }
    ]
}
```

You can mix both styles in the same list, and combine them with `imageUrls` and `imagesBase64`. Omit `storeId` to use **this run's own default store** (handy when an earlier step wrote the images there).

**What you get back:** each image appears in the results under the identifier `kvs:<storeId>:<key>` (or `kvs:<key>` when you used the default store).

**What gets skipped or flagged:**

- In **whole-store** mode, records that aren't images (like the `INPUT` record, JSON, or text) are skipped automatically — no error.
- In **specific-file** mode, a key that's missing or isn't an image is reported in the **Global Errors** dataset view, and the run continues with the rest.

> **⚠️ Common mistakes**
>
> - **Wrong store name.** A named store uses a tilde: `username~store-name`, *not* a slash. When in doubt, copy the **Store ID** from the Console instead.
> - **The record isn't an image.** Only binary image records work — a record saved as JSON or plain text is rejected.
> - **Permissions.** This run's **default** store always works. A **named** store must belong to you (or be shared with you); otherwise you'll see an "insufficient permissions" error in **Global Errors**.

#### Integrating from Python

Using the [Apify API client for Python](https://docs.apify.com/api/client/python). To process a **local image file** with **no base64**, upload its raw bytes to a Key-Value Store and reference the record:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## 1) Upload the raw image bytes to a Key-Value Store (no base64)
store = client.key_value_stores().get_or_create(name="my-lens-images")
kvs = client.key_value_store(store["id"])
with open("photo.jpg", "rb") as f:
    kvs.set_record("photo1", f.read(), content_type="image/jpeg")  # image/png for PNG

## 2) Run the actor against that record (this waits for the run to finish)
run = client.actor("borderline/google-lens").call(run_input={
    "searchTypes": ["all", "visual-match"],
    "imageKvsRecords": [{"key": "photo1", "storeId": store["id"]}],
    "language": "en",
})

## 3) Read the results
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

To process a whole folder, upload each file under its own key and pass `"imageKvsRecords": [{"storeId": store["id"]}]` to grab them all at once.

Prefer to inline the image instead? Base64 works too:

```python
import base64

b64 = base64.b64encode(open("photo.jpg", "rb").read()).decode()
run_input = {"searchTypes": ["all"], "imagesBase64": [b64], "language": "en"}
```

#### Dataset Views

Results are organized into one tab per search type in the Apify console, each with readable columns —
page title, URL, price, extracted text — instead of raw JSON. Access them from the Storage tab, or via
the API by adding `?view=<id>` to the dataset items URL (for example `?view=ocr`).

Views only change how the Console displays the data. JSON, CSV and Excel exports always contain the
complete raw item, including the fields no view shows (word positions, base64 renderings, thumbnails).

***

For additional guidance, refer to the [Apify documentation](https://docs.apify.com) or contact support for assistance. Happy scraping! 🚀

# Actor input Schema

## `searchTypes` (type: `array`):

Select the types of searches you want to perform

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

List of image urls to search with google lens

## `imagesBase64` (type: `array`):

List of images encoded in base64 to search with Google Lens. Accepts raw base64 or a data URI (data:image/png;base64,...). Provide at least one of imageUrls or imagesBase64.

## `imageKvsRecords` (type: `array`):

List of images to read from an Apify Key-Value Store. Each item is an object. Use { "key": "<record-key>", "storeId": "<store-id-or-name>" } to read one specific record, or { "storeId": "<store-id-or-name>" } with NO key to read every image in that store (non-image records are skipped). Omit storeId to use this run's default store. Provide at least one of imageUrls, imagesBase64, or imageKvsRecords.

## `aiModeQuestions` (type: `array`):

Questions to ask the AI mode ('ai-mode' must be selected in searchTypes)

## `translateLanguage` (type: `string`):

Select the language to translate the image to ('translate-ocr' must be selected in searchTypes)

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

Select language (default is en). Choose a language to specify the language for search results.

## Actor input object example

```json
{
  "searchTypes": [
    "all",
    "ai-mode",
    "translate-ocr"
  ],
  "imageUrls": [
    {
      "url": "https://console.apify.com/img/logos_apify/logo_apify_full_white_text.svg"
    }
  ],
  "imageKvsRecords": [],
  "translateLanguage": "en",
  "language": "en"
}
```

# Actor output Schema

## `all` (type: `string`):

Pages Google Lens found for your image, from the Lens "All" tab.

## `ai-mode` (type: `string`):

Each question you asked about the image and the answer Google Lens gave.

## `translate-ocr` (type: `string`):

The text read in your image, next to that same text in your target language.

## `exact-match` (type: `string`):

Pages republishing the very same image, with the size of the copy hosted there.

## `visual-match` (type: `string`):

Images that look like yours without being the same file, with the page hosting each one.

## `products` (type: `string`):

Products Google Lens matched to your image, with price, store and rating.

## `homework` (type: `string`):

Explanations and study resources for the exercise in your image.

## `ocr` (type: `string`):

The text Google Lens read in your image, one row per image.

## `global` (type: `string`):

Images no search type could process, and run-level failures.

# 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 = {
    "searchTypes": [
        "all",
        "ai-mode",
        "translate-ocr"
    ],
    "imageUrls": [
        {
            "url": "https://console.apify.com/img/logos_apify/logo_apify_full_white_text.svg"
        }
    ],
    "imageKvsRecords": [],
    "translateLanguage": "en",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("borderline/google-lens").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 = {
    "searchTypes": [
        "all",
        "ai-mode",
        "translate-ocr",
    ],
    "imageUrls": [{ "url": "https://console.apify.com/img/logos_apify/logo_apify_full_white_text.svg" }],
    "imageKvsRecords": [],
    "translateLanguage": "en",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("borderline/google-lens").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 '{
  "searchTypes": [
    "all",
    "ai-mode",
    "translate-ocr"
  ],
  "imageUrls": [
    {
      "url": "https://console.apify.com/img/logos_apify/logo_apify_full_white_text.svg"
    }
  ],
  "imageKvsRecords": [],
  "translateLanguage": "en",
  "language": "en"
}' |
apify call borderline/google-lens --silent --output-dataset

```

## MCP server setup

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

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/MaNVYRogwHemtywEz/builds/veWpBXc2xISSX6lcx/openapi.json