# Google Images Scraper (`scrapebase/google-images-scraper`) Actor

✨ Google Images Scraper to extract image results from Google quickly and at scale. Collect image URLs, titles, sources, and metadata with ease. Ideal for research, datasets, and analysis. Features: ⚡ fast scraping • 📊 clean output • 🔍 image insights • 🌍 scalable automation

- **URL**: https://apify.com/scrapebase/google-images-scraper.md
- **Developed by:** [ScrapeBase](https://apify.com/scrapebase) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

### Google Images Scraper

Google Images Scraper is a fast, scalable Google images scraping tool that collects image URLs, titles, source pages, and metadata from Google Image Search. It helps developers, marketers, data analysts, and researchers scrape Google images at scale, acting as a reliable google image scraper and google image search scraper for structured datasets. With robust proxy fallback and real-time dataset updates, it enables automated pipelines to download images from Google search, power AI datasets, and fuel analysis workflows.

### What data / output can you get?

Below are the exact fields this google images crawler outputs to the Apify dataset. Each record corresponds to one image result.

| Data type        | Description                                           | Example value |
| --- | --- | --- |
| query            | The search keyword used for the image query           | technology |
| imageUrl         | Direct link to the image                              | https://miro.medium.com/v2/resize:fit:1400/1*6-dNFz13P5prRz_kYaInXg.jpeg |
| title            | Title text extracted from the result panel            | Is Technology Ruining Your Experience ... |
| imageWidth       | Image width in pixels (if detected)                   | 1400 |
| imageHeight      | Image height in pixels (if detected)                  | 1025 |
| thumbnailUrl     | Thumbnail image URL (may equal imageUrl when no tbnid)| https://encrypted-tbn0.gstatic.com/images?q=tbn:7XZB0ElBde-RCM |
| thumbnailWidth   | Thumbnail width in pixels (defaults to 300 if unknown)| 300 |
| thumbnailHeight  | Thumbnail height in pixels (defaults to 200 if unknown)| 200 |
| contentUrl       | Source page URL where the image is hosted             | https://medium.com/jacob-morgan/is-technology-ruining-your-experience-at-work-58eaf3ec40a7 |
| origin           | Hostname/domain derived from contentUrl               | medium.com |

Notes:
- origin is set to "unknown" if the source page cannot be resolved.
- When a dedicated thumbnail ID (tbnid) is present, thumbnailUrl points to an encrypted-tbn0.gstatic.com resource. Otherwise it falls back to imageUrl.
- You can export the Output dataset from Apify in formats like JSON, CSV, or Excel for downstream use.

### Key features

- ⚙️ Robust proxy fallback
  Automatically cycles through direct, datacenter, and residential proxies with retries if blocking is detected. Keeps your google serp image scraper resilient during scale.

- ⚡ Real-time dataset updates
  Enable pushToDatasetRealtime to stream each image record to the Output table as soon as it’s scraped—ideal for monitoring and pipelines that scrape Google images continuously.

- 🧠 Block detection & consent handling
  Detects CAPTCHA/unusual traffic pages and handles Google consent dialogs when present to maintain smooth runs.

- 🧼 Quality filters & de-duplication
  Skips data URLs and known Google-hosted assets (e.g., gstatic, googleusercontent) and avoids duplicates to keep your google images data extraction clean.

- 🧩 Memory-optimized Playwright engine
  Launches a fresh Chromium instance per query, blocks non-essential resources, and uses a compact viewport for stable bulk operations.

- 🎯 Precise metadata extraction
  Captures imageUrl, dimensions, source page (contentUrl), and origin domain—perfect for automatic google images downloader pipelines and bulk download google images workflows using the URLs.

- 💻 Developer-friendly automation
  Works seamlessly with the Apify API and SDKs, making it a practical google image scraping api for both google images scraper node.js and google image scraper python projects.

### How to use Google Images Scraper - step by step

1. Create an Apify account
   Sign up or log in to Apify.

2. Open the actor
   Search for “Google Images Scraper” in the Apify Store and open the actor.

3. Add your queries
   In Input, provide one or more keywords in queries (e.g., ["nature", "technology"]).

4. Set limits and mode
   - maxImages: Number of images to collect per query (default 10; up to 1000).
   - headless: Keep it true for production stability.

5. Configure proxy behavior
   Use proxyConfiguration to control proxies. The actor includes built-in fallback from none → datacenter → residential to handle blocking.

6. Choose real-time output
   Set pushToDatasetRealtime to true to stream results to the Output dataset as they are found.

7. Run the scraper
   Click Start. The actor will open Google Images, click through thumbnails, and extract image metadata until limits are reached.

8. Export your results
   Open the run’s Dataset tab to browse and download records in your preferred format (e.g., JSON or CSV). Use these URLs with a google image downloader workflow to fetch the actual files.

Pro Tip: Chain this google images scraping tool with other Apify actors or your own scripts to build an automatic google images downloader pipeline that fetches and stores images in bulk.

### Use cases

| Use case name | Description |
| --- | --- |
| AI/ML dataset creation | Build large training sets by extracting image URLs and metadata for computer vision and labeling workflows. |
| SEO & content research | Analyze visual SERPs for target keywords to benchmark competitors and track trends in image search. |
| Brand monitoring | Detect where logos or brand visuals appear online with origin domains for compliance or outreach. |
| Media & editorial sourcing | Quickly gather candidate images and source pages for journalism, blogs, or newsletters. |
| E-commerce enrichment | Collect product-related images and content URLs for catalogs, comparison pages, or audits. |
| Academic studies | Support research by exporting structured image result datasets for analysis and reproducibility. |
| API pipelines | Integrate this google image scraping api with Node.js/Python to power automated data flows and storage. |

### Why choose Google Images Scraper?

This tool is built for precision and reliability—combining Playwright automation with smart proxy fallback and real-time outputs to scrape google images at scale.

- ✅ Accurate, structured output: Clean fields for image URLs, titles, dimensions, source pages, and domains.
- 🚀 Scales per query: Control maxImages per keyword (default 10; up to 1000 per query).
- 🧠 Smart anti-blocking: Detects blocks and falls back across proxy modes automatically.
- 🔌 Developer-ready: Use with the Apify API, apify-client for Python, or Node.js for automation.
- 🛡️ Safer than extensions: No brittle browser plugins—production-ready infrastructure on Apify Cloud.
- 💸 Cost-effective workflows: Stream results in real time, export datasets, and integrate with your data stack.

In short: a dependable google images scraper that outperforms manual methods and unstable extensions for sustained automation.

### Is it legal / ethical to use Google Images Scraper?

Yes—when used responsibly. This actor extracts publicly available metadata (e.g., URLs, titles, dimensions, source pages) from Google Image Search results. It does not authenticate into private areas or access gated data.

Guidelines for compliant use:
- Scrape only public result data and respect platform terms.
- Verify usage rights before downloading or using images commercially.
- Adhere to relevant regulations (e.g., GDPR/CCPA) and consult your legal team for specific use cases.

Using filters like usage rights on Google (manually) and limiting to metadata collection helps ensure ethical, compliant operations.

### Input parameters & output format

Example JSON input
```json
{
  "queries": [
    "nature",
    "technology"
  ],
  "maxImages": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "headless": true,
  "pushToDatasetRealtime": true
}
````

Parameter reference

| Field | Type | Description | Default | Required |
| --- | --- | --- | --- | --- |
| queries | array | List of search queries or keywords to scrape images for. Can be single query or multiple queries. | Prefill: \["nature"] | Yes |
| maxImages | integer | Maximum number of images to scrape per query (1-1000). | 10 | No |
| proxyConfiguration | object | Choose which proxies to use. If Google rejects the proxy, a residential proxy will be used as a fallback. | {"useApifyProxy": false} | No |
| headless | boolean | Run browser in headless mode (recommended for production). | true | No |
| pushToDatasetRealtime | boolean | If enabled, each scraped image is saved to the actor Output table immediately. If disabled, all results are saved at the end. | true | No |

Example JSON output

```json
[
  {
    "query": "technology",
    "imageUrl": "https://miro.medium.com/v2/resize:fit:1400/1*6-dNFz13P5prRz_kYaInXg.jpeg",
    "title": "Is Technology Ruining Your Experience ...",
    "imageWidth": 1400,
    "imageHeight": 1025,
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:7XZB0ElBde-RCM",
    "thumbnailWidth": 300,
    "thumbnailHeight": 200,
    "contentUrl": "https://medium.com/jacob-morgan/is-technology-ruining-your-experience-at-work-58eaf3ec40a7",
    "origin": "medium.com"
  },
  {
    "query": "technology",
    "imageUrl": "https://cdn.britannica.com/84/203584-050-57D326E5/speed-internet-technology-background.jpg",
    "title": "History of Technology Timeline ...",
    "imageWidth": 1600,
    "imageHeight": 1131,
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:I9RUPVPHjvqr1M",
    "thumbnailWidth": 300,
    "thumbnailHeight": 200,
    "contentUrl": "https://www.britannica.com/story/history-of-technology-timeline",
    "origin": "www.britannica.com"
  }
]
```

Notes:

- origin may be "unknown" when the source URL cannot be parsed.
- thumbnailWidth and thumbnailHeight default to 300x200 when image dimensions are not available.

### FAQ

#### Is there an official Google Images API?

No. Google does not provide a public Google Image Search API. This actor functions as a google image scraping api alternative via the Apify platform.

#### Can I scrape Google Images with Python?

Yes. Use the Apify API or the apify-client Python package to run this google image scraper python workflow and fetch dataset results programmatically.

#### Does it work with Node.js/NPM?

Yes. You can trigger runs and read datasets using the Apify SDK for Node.js, making it a practical google images scraper node.js integration.

#### Can it download the actual images, not just URLs?

The actor outputs imageUrl fields. To bulk download google images, pair the output with an image-downloader actor or your own script to fetch the files.

#### How many images can I scrape per query?

You control this via maxImages. The default is 10, and you can set up to 1000 per query.

#### How does it handle blocking?

It detects CAPTCHA/unusual traffic pages and automatically falls back across proxy modes (none → datacenter → residential) with retries, improving reliability for scrape google images tasks.

#### Is there a chrome extension version?

This is an Apify actor designed for API and cloud workflows rather than a google images scraper chrome extension. It’s more stable for automation and scaling.

#### Is it free to use?

You can run it on Apify with available plan credits. Check your Apify account for current free tier details and pricing.

### Closing CTA / Final thoughts

Google Images Scraper is built for structured, reliable Google images data extraction at scale. It delivers clean fields (image URLs, dimensions, titles, sources) with smart proxy fallback and real-time dataset updates to power research, SEO, and AI pipelines. Whether you’re a marketer, developer, analyst, or researcher, you can integrate it via the Apify API for an automatic google images downloader flow in Python or Node.js. Start extracting smarter image datasets—clean, structured, and automation-ready.

# Actor input Schema

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

✍️ List of search phrases (e.g. nature, product shots, logos). One query per line in the editor.

## `maxImages` (type: `integer`):

🎚️ Cap how many unique images to keep for each keyword (1–1000). The log shows progress toward this goal in real time.

## `proxyConfiguration` (type: `object`):

⚙️ Pick proxy groups/countries in the picker. When enabled, the actor uses your selection for the browsing session.

## `headless` (type: `boolean`):

✅ On (default): best for Apify cloud. 🔲 Off: useful for debugging on your machine.

## `pushToDatasetRealtime` (type: `boolean`):

💾 ON: each image is pushed to the dataset immediately — your Output tab updates during the run. 📦 OFF: everything uploads once at the end.

## Actor input object example

```json
{
  "queries": [
    "nature"
  ],
  "maxImages": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "headless": true,
  "pushToDatasetRealtime": true
}
```

# 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 = {
    "queries": [
        "nature"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebase/google-images-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 = {
    "queries": ["nature"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapebase/google-images-scraper").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 '{
  "queries": [
    "nature"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapebase/google-images-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapebase/google-images-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Images Scraper",
        "description": "✨ Google Images Scraper to extract image results from Google quickly and at scale. Collect image URLs, titles, sources, and metadata with ease. Ideal for research, datasets, and analysis. Features: ⚡ fast scraping • 📊 clean output • 🔍 image insights • 🌍 scalable automation",
        "version": "0.1",
        "x-build-id": "yQWpoOU9T3ecYdYgF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapebase~google-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapebase-google-images-scraper",
                "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/scrapebase~google-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapebase-google-images-scraper",
                "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/scrapebase~google-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapebase-google-images-scraper",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🔤 Keywords / queries",
                        "type": "array",
                        "description": "✍️ List of search phrases (e.g. nature, product shots, logos). One query per line in the editor.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxImages": {
                        "title": "🔢 Max images per query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "🎚️ Cap how many unique images to keep for each keyword (1–1000). The log shows progress toward this goal in real time.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🌍 Apify Proxy",
                        "type": "object",
                        "description": "⚙️ Pick proxy groups/countries in the picker. When enabled, the actor uses your selection for the browsing session."
                    },
                    "headless": {
                        "title": "👻 Headless browser",
                        "type": "boolean",
                        "description": "✅ On (default): best for Apify cloud. 🔲 Off: useful for debugging on your machine.",
                        "default": true
                    },
                    "pushToDatasetRealtime": {
                        "title": "⚡ Live save to Output table",
                        "type": "boolean",
                        "description": "💾 ON: each image is pushed to the dataset immediately — your Output tab updates during the run. 📦 OFF: everything uploads once at the end.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
