# Reverse Image Search API - Google Lens | TinEye Alternative (`thodor/google-lens-exact-matches`) Actor
Find where any image appears online. Bulk reverse image search via Google Lens with original source URL resolution. Covers Instagram, TikTok, eBay, Amazon and the entire web.
- **URL**: https://apify.com/thodor/google-lens-exact-matches.md
- **Developed by:** [Thodor](https://apify.com/thodor) (community)
- **Categories:** Social media, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.80 / 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/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".
## 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.
The best way to integrate Actors is as follows.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).
For usage examples, see the [API](#api) section below.
For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).
# README
### What does Reverse Image Search - Google Lens Exact Match & URL Resolver do?
This actor is a **reverse image search API** that takes any image URL, runs it through **Google Lens**, and returns every exact-match page Lens found, including the page URL, title, publisher, publication date, and thumbnail. Google Lens no longer returns the direct URL of each matched image — only the page where it was found. To bridge that gap, this actor can optionally visit each result page and **find the original-source image URL**, so you get a direct download link instead of just the page address.
It is a clean, JSON-first **Google Lens API** for developers, OSINT teams, brand-protection workers, photographers, and e-commerce operators. Try it from the Apify Console, call it from the [Apify API](https://docs.apify.com/api/v2), schedule it as a cron job, or wire it into n8n, Zapier, Make, or your own pipeline. Apify handles residential proxy rotation, retries on 429 / `/sorry/` blocks, scaling, and monitoring.
Unlike most reverse image search tools, this one forces `vsint=FULL_IMAGE` so Lens searches the **whole frame** instead of an auto-cropped subsection. The result is true exact matches, not visually-similar suggestions.
### Why use this Google Lens reverse image search API?
- **Reverse image search at scale.** Bulk / batch reverse image search across hundreds or thousands of source images per run. Output streams to the dataset as it lands. Export to JSON, CSV, Excel, or HTML.
- **URL resolver built in.** Most reverse image search tools stop at the page URL. This actor goes a step further and finds the **actual image file** on each result page — so you get a real, downloadable image URL, not just where Lens saw it.
- **Exact-match focus.** Full-frame Lens queries cut out the noise of visually-similar matches, so what you get back is genuinely the same image. Exactly what you need for image-source lookup, copyright takedowns, and image-theft detection.
- **Pay only for what you get.** PAY_PER_EVENT pricing: one tiny charge per Lens search, one per match returned. No idle compute units, no surprises.
- **No CAPTCHA dance for you.** Apify residential proxies rotate per attempt, with automatic retry on a fresh exit IP for any blocked request.
### How to use this reverse image search Actor
1. Open the actor in the [Apify Console](https://console.apify.com/).
2. Paste one or more image URLs into the **Image URLs** field. Direct links to `.jpg`, `.png`, `.webp`, `.heic`, or `.avif` files all work, and bigger originals give cleaner exact matches.
3. Leave **Resolve original-source image URL** turned on (recommended) for the full pipeline, or turn it off for a faster, cheaper run when you only need the page URLs and titles.
4. Click **Start**.
5. Watch results stream into the Dataset tab. Download as JSON, CSV, Excel, or HTML when the run finishes, or fetch them via the API while the run is still going.
To automate this, hit the [Apify API](https://docs.apify.com/api/v2) directly or use one of the official client libraries ([Python](https://docs.apify.com/api/client/python/), [JavaScript](https://docs.apify.com/api/client/js/)). Every run accepts the same JSON body as the Input tab.
### Input
| Field | Type | Required | Description |
|---|---|---|---|
| `imageUrls` | array of URLs | yes | Image URLs to reverse-search. Accepts bare strings or `{"url": "..."}` entries. |
| `resolve` | boolean | no (default `true`) | When `true`, each match is enriched with the original-source image URL — when we can still find it on the destination page. Sometimes the image has been moved or deleted, and you only pay for the matches we successfully resolve. |
| `country` | string (ISO 3166-1 alpha-2) | no (default `US`) | Country used both as the Apify residential proxy exit region for every Google Lens request *and* as the `gl=` parameter sent to Lens (biases the regional index). |
Example input JSON:
```json
{
"imageUrls": [
"https://example.com/photo.jpg",
"https://example.com/another.png"
],
"resolve": true,
"country": "US"
}
````
### Output
You can download the dataset in various formats such as **JSON**, **HTML**, **CSV**, or **Excel**, or read it as a spreadsheet directly from the Apify Console.
One dataset record per Lens match. A single input image typically produces several to several dozen output rows:
```json
{
"source_image_url": "https://example.com/photo.jpg",
"page_url": "https://news.example.org/article/123",
"title": "Original story about the photo",
"publisher": "Example News",
"published_date": "2024-09-12",
"lens_thumbnail_url": "https://encrypted-tbn0.gstatic.com/...",
"lens_expected_width": 1920,
"lens_expected_height": 1080,
"scraped_date": "2026-05-14",
"resolved_image_url": "https://news.example.org/wp-content/uploads/2024/09/photo-full.jpg",
"resolve_status": "match_definitely",
"page_status": 200,
"thumbnail_mismatch": false
}
```
#### Data fields
| Field | Description |
|---|---|
| `source_image_url` | The image you searched |
| `page_url` | Web page where Google Lens found this match |
| `title` | Page title as Lens displays it |
| `publisher` | Publisher / site name |
| `published_date` | Publication date when Lens surfaces one (ISO 8601) |
| `lens_thumbnail_url` | The thumbnail Lens shows for this match (usable as-is) |
| `lens_expected_width` / `lens_expected_height` | Dimensions Lens reports for the match |
| `scraped_date` | Date this actor row was produced |
| `resolved_image_url` | The original-source image file on the destination page (present when `resolve=true`) |
| `resolve_status` | `match_definitely`, `match_maybe`, `match_no`, `no_candidate`, `fetch_failed`, or `thumbnail_failed` |
| `page_status` | HTTP status of the destination page fetch |
| `thumbnail_mismatch` | `true` when the resolved image didn't match the Google Lens thumbnail for this row, but matched a different Google Lens thumbnail from the same search |
### Use cases for reverse image search
**OSINT reverse image search and investigation.** Trace where a photograph first appeared online, who has republished it, and on what dates. Investigators get the full-resolution original via the URL resolver, not just the Lens thumbnail. That is critical when verifying authenticity or building a timeline.
**Dating profile verification.** Run a list of profile photos through the actor to catch stolen or recycled images. Reverse image search for dating profiles works across Tinder, Hinge, and every other major dating app, anywhere Google has indexed the photos. Useful for both individual safety checks and Trust & Safety teams running bulk reverse image search for dating sites.
**Scammer and catfish detection.** A scammer's profile picture often originates from a stock photo, a public Instagram account, or another victim's social media. Reverse image search scammer photos to surface those origins and prior fraud reports.
**Copyright protection, artwork, and image-theft detection.** Photographers, illustrators, and stock-photo licensees use bulk reverse image search artwork to find unauthorized reuse. Get downloadable evidence URLs straight from the dataset and feed them into your DMCA workflow. Reverse image search copyright work is exactly what the URL resolver is designed for.
**E-commerce product matching.** Reverse image search clothing, an outfit, furniture, jewelry, or any product photo to find duplicate listings, knock-offs, and competitor pricing across marketplaces.
**Social media monitoring and brand protection.** Track image usage online across every major platform, and find where a brand asset, leaked screenshot, or viral photo has spread.
**Specialized lookups.** Reverse image search plants, mugshots, art, anime stills, or anything else where you want the authoritative *page* of context, not just visually-similar images.
### Supported platforms and sources
Google Lens indexes the public web, so any page reachable by Googlebot can surface as a match. In practice you'll routinely see results from:
- **Social media:** Facebook, Pinterest, Twitter / X, Instagram, TikTok, YouTube, LinkedIn, Tumblr, Reddit, VK
- **Marketplaces:** eBay, AliExpress, Taobao, Depop, Shutterstock, Etsy
- **Image and art hosts:** DeviantArt, Pixiv, Flickr, Imgur, ArtStation
- **News and publisher sites:** every major outlet plus long-tail blogs
- **Dating sites and forums** where Google has indexed the photo
The actor does not separately query each platform's own search endpoint. It leverages Google Lens' single, consistent index of all of them. That means a single reverse image search call effectively gives you a Facebook reverse image search, Pinterest reverse image search, Twitter reverse image search, TikTok reverse image search, Depop reverse image search, eBay reverse image search, and so on, wherever Google has crawled.
Note: private content (private Instagram, closed Facebook groups, WhatsApp messages, Discord servers) is not indexable by Google and therefore not reachable by Lens or this actor.
### Tips and advanced options
- **Disable `resolve` for speed and cost savings.** With resolve off, each input image finishes in a few seconds. With resolve on it can take 30-90 seconds per image because the actor visits every result page to find the original image. Turn it off when you only need page URLs and titles.
- **Use big, clean source images.** Lens is most precise with originals ≥1000px on the long edge. Tiny thumbnails or heavily-cropped versions produce more visually-similar noise and fewer true exact matches.
- **Interpret `resolve_status` correctly.** `match_definitely` = high-confidence match. `match_maybe` = likely match. `match_no` = page loaded but the original image wasn't found. `no_candidate` = page loaded but had no usable images. `fetch_failed` = paywall, captcha, or network block. `thumbnail_failed` = the Lens thumbnail couldn't be loaded, so the result page wasn't tried (we still kept the page URL).
- **`thumbnail_mismatch=true`** means the resolved image didn't match the Google Lens thumbnail for this row, but did match a different Google Lens thumbnail from the same search. Usually happens when Lens displays a cropped or scaled thumbnail and the page hosts a clean original — the match is still real.
- **Schedule it.** Use [Apify Schedules](https://docs.apify.com/platform/schedules) to monitor image leaks or stolen art daily / weekly. Pair with [Apify Webhooks](https://docs.apify.com/platform/integrations/webhooks) to notify Slack, Discord, or email whenever new matches show up.
- **Combine with other actors.** Pipe the output into a downstream actor that screenshots `page_url`, runs OCR, or scores `publisher` against a reputation list.
### FAQ
**Does this resolve images from the following domains?** Yes, across the public web. From real runs we routinely get resolved image URLs from:
- **Social:** Facebook, Instagram, Threads, TikTok, X / Twitter, Pinterest, LinkedIn, YouTube
- **Encyclopedic:** Wikipedia (all language editions), Wikimedia Commons, Britannica
- **News & media:** BBC, Forbes, Reuters, CNN, CNBC, India Today, Hindustan Times, The Daily Beast, and most other major outlets
- **E-commerce:** Amazon, eBay, AliExpress, Shutterstock
- **Long tail:** Medium, Substack, WordPress blogs, fandom wikis, personal sites
What doesn't resolve cleanly:
- **Private or login-walled content** — private Instagram accounts, closed Facebook groups, Discord, WhatsApp, paywalled articles. If Google can't index it, we can't find it
- **Sites behind aggressive bot protection** — parts of Reddit, namu.wiki, and certain regional outlets sometimes return `fetch_failed`
**Why don't I get results for some images?** Either Lens has no exact match in its index, or every proxy attempt was blocked. The actor logs both cases distinctly. Try a different version of the source image (typically a larger or less cropped one).
**Why does the resolved image sometimes differ in size from the Lens thumbnail?** Publishers often serve compressed, resized, or watermarked thumbnails on listing pages. The resolver looks for the largest, highest-priority visually-matching image on the page. That's typically the original asset, not the same crop Lens showed.
**Can I use this for a video or a GIF?** Lens treats animated GIFs as their first frame. Reverse image search on a video isn't directly supported. Extract a representative frame yourself and feed it as a still image.
**How does this compare with other Apify Google Lens actors?** This actor specializes in **exact-match reverse image search with original-image URL resolution**. Other Google Lens actors on Apify focus on visually-similar matches, OCR, translation, or AI-mode Lens features. If you need OCR or translation, look at those. If you need the page URL *and* the actual downloadable original image for each exact match, at scale, with structured JSON output, this is the right tool.
# Actor input Schema
## `imageUrls` (type: `array`):
Image URLs to search through Google Lens. Each URL is sent to Lens with `vsint=FULL_IMAGE` so the whole frame is matched (no auto-cropping). Accepts bare strings or `{"url": "..."}` objects.
## `resolve` (type: `boolean`):
When enabled, each Lens result is enriched with the **original-source image URL** by fetching the result page, ranking its `![]()
` candidates by priority + dimensions, and phash-comparing each candidate against the Lens thumbnail. Disable for ~5-10x speed and lower cost when you only need the page URL + title.
## `country` (type: `string`):
Country used for two things: (1) the Apify residential proxy exit IP for every Google Lens request, and (2) the `gl=` parameter sent to Lens, which biases the regional index. ISO 3166-1 alpha-2 code.
## Actor input object example
```json
{
"imageUrls": [
"https://upload.wikimedia.org/wikipedia/commons/thumb/c/ce/Marie_Curie_%28Nobel-Chem%29.jpg/960px-Marie_Curie_%28Nobel-Chem%29.jpg"
],
"resolve": false,
"country": "US"
}
```
# Actor output Schema
## `results` (type: `string`):
No description
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"imageUrls": [
"https://upload.wikimedia.org/wikipedia/commons/thumb/c/ce/Marie_Curie_%28Nobel-Chem%29.jpg/960px-Marie_Curie_%28Nobel-Chem%29.jpg"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("thodor/google-lens-exact-matches").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "imageUrls": ["https://upload.wikimedia.org/wikipedia/commons/thumb/c/ce/Marie_Curie_%28Nobel-Chem%29.jpg/960px-Marie_Curie_%28Nobel-Chem%29.jpg"] }
# Run the Actor and wait for it to finish
run = client.actor("thodor/google-lens-exact-matches").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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/c/ce/Marie_Curie_%28Nobel-Chem%29.jpg/960px-Marie_Curie_%28Nobel-Chem%29.jpg"
]
}' |
apify call thodor/google-lens-exact-matches --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=thodor/google-lens-exact-matches",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Reverse Image Search API - Google Lens | TinEye Alternative",
"description": "Find where any image appears online. Bulk reverse image search via Google Lens with original source URL resolution. Covers Instagram, TikTok, eBay, Amazon and the entire web.",
"version": "0.4",
"x-build-id": "DV73q4kiNcsegnsqb"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/thodor~google-lens-exact-matches/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-thodor-google-lens-exact-matches",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/thodor~google-lens-exact-matches/runs": {
"post": {
"operationId": "runs-sync-thodor-google-lens-exact-matches",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/thodor~google-lens-exact-matches/run-sync": {
"post": {
"operationId": "run-sync-thodor-google-lens-exact-matches",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"imageUrls"
],
"properties": {
"imageUrls": {
"title": "Image URLs",
"type": "array",
"description": "Image URLs to search through Google Lens. Each URL is sent to Lens with `vsint=FULL_IMAGE` so the whole frame is matched (no auto-cropping). Accepts bare strings or `{\"url\": \"...\"}` objects.",
"items": {
"type": "string"
}
},
"resolve": {
"title": "Resolve original-source image URL",
"type": "boolean",
"description": "When enabled, each Lens result is enriched with the **original-source image URL** by fetching the result page, ranking its `![]()
` candidates by priority + dimensions, and phash-comparing each candidate against the Lens thumbnail. Disable for ~5-10x speed and lower cost when you only need the page URL + title.",
"default": false
},
"country": {
"title": "Country",
"enum": [
"US",
"GB",
"DE",
"FR",
"NL",
"BE",
"ES",
"IT",
"PT",
"BR",
"CA",
"AU",
"IN",
"JP",
"KR",
"MX",
"AR",
"CL",
"CO",
"PL",
"CZ",
"AT",
"CH",
"SE",
"NO",
"DK",
"FI",
"IE",
"ZA",
"RU",
"TR",
"UA",
"RO",
"HU",
"GR",
"IL",
"SA",
"AE",
"EG",
"NG",
"KE",
"TH",
"VN",
"ID",
"MY",
"SG",
"PH",
"TW",
"HK",
"NZ"
],
"type": "string",
"description": "Country used for two things: (1) the Apify residential proxy exit IP for every Google Lens request, and (2) the `gl=` parameter sent to Lens, which biases the regional index. ISO 3166-1 alpha-2 code.",
"default": "US"
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```