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

Extract image results from Google Images using the Google Images Scraper. Collect image URLs, titles, source websites, thumbnails, and search result data automatically. Ideal for research, dataset creation, SEO analysis, and visual content discovery.

- **URL**: https://apify.com/scrapapi/google-images-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **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 headless, Playwright-powered Google image search scraper that extracts image URLs, thumbnails, titles, source pages, and site origins from Google Images results. It solves the manual effort of collecting visuals and metadata by automating Google Images browsing and streaming records directly to your Apify dataset. Built for marketers, developers, data analysts, and researchers, this Google Images scraper tool scales from one-off lookups to multi-keyword runs and integrates cleanly with the Apify platform and Google Images scraping API workflows.

### What data / output can you get?

Below are the exact fields this actor saves to the dataset when you scrape Google Images results. You can export the dataset to JSON, CSV, or Excel from Apify.

| Data type        | Description                                                | Example value |
| --- | --- | --- |
| query            | Search term that produced the image result                 | "nature" |
| imageUrl         | Direct link to the full image                              | "https://example.com/photo.jpg" |
| title            | Title text associated with the result                      | "Stunning nature photography" |
| imageWidth       | Full image width (pixels, if known)                        | 1600 |
| imageHeight      | Full image height (pixels, if known)                       | 1200 |
| thumbnailUrl     | Google Images thumbnail URL or derived preview             | "https://encrypted-tbn0.gstatic.com/images?q=tbn:ABC123" |
| thumbnailWidth   | Thumbnail width (pixels)                                   | 300 |
| thumbnailHeight  | Thumbnail height (pixels)                                  | 200 |
| contentUrl       | Source page URL that hosts the image                       | "https://example.com/gallery.html" |
| origin           | Origin domain (host) of the source page or image           | "example.com" |

Note: Width/height values may be 0 when not present on the result. As soon as each image is collected, it can be streamed to the Output dataset in real time or saved in a batch at the end.

### Key features

- ⚡ Real-time dataset streaming
  When pushToDatasetRealtime is on, each image record is pushed immediately to your Apify dataset — perfect for live monitoring and pipelines that consume SERP image results as they appear.

- 🧭 Two-layout extraction for better coverage
  The actor collects from the standard Google Images layout (tbm=isch) and automatically retries with an alternate layout (udm=2) if needed to maximize recall per query.

- 🔍 Smart pagination + infinite scroll
  Combines page-by-page loading with controlled scrolling to merge additional thumbnails and extract more results per Google image search scraper run.

- 🔁 Built-in retries and de-duplication
  Per-query retry logic and duplicate filtering ensure clean results with unique image/thumbnail pairs.

- 👻 Headless Chrome/Chromium
  Runs a Playwright browser (Chrome channel when available, otherwise bundled Chromium). Headless mode is enabled by default for speed and stability.

- 🔐 Optional Apify Proxy
  Configure proxy groups/countries with proxyConfiguration to improve resilience when networks are restrictive or when geo checks appear.

- 🧩 Developer-friendly and automation-ready
  Use via the Apify UI or programmatically with the Apify API to power Google Images scraping API workflows in Python, Node.js, or your orchestration stack.

- 🗂️ Flexible exports
  Access results from the Apify dataset and download to JSON, CSV, or Excel for analysis, enrichment, or downstream “automated Google image downloader” steps.

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

1. Sign in to Apify
   Create a free Apify account and navigate to the Google Images Scraper actor.

2. Add your queries
   In the Input, paste one or more search phrases into queries (one per line). Example: “nature”, “product shots”, “logos”.

3. Set result limits
   Adjust maxImages to control how many unique images you collect per query (1–1000).

4. Choose live vs. batch output
   - pushToDatasetRealtime: true streams each image to the Output dataset as soon as it’s collected.
   - Set it to false if you prefer all rows to upload once the run finishes.

5. Configure headless and proxy (optional)
   - headless defaults to true for cloud runs.
   - Use proxyConfiguration to route through Apify Proxy when you encounter rate limits or geography checks.

6. Run the scraper
   Click Start. The actor opens a Playwright browser, navigates Google Images, and begins collecting image metadata.

7. Monitor progress
   Watch the run log for live status messages and see rows appear in the Dataset tab (if live push is on).

8. Export results
   Open the Dataset tab to download your results in JSON, CSV, or Excel — ready for SEO analysis, catalogs, or a Google Images bulk download pipeline downstream.

Pro tip: Trigger this actor via the Apify API to build a repeatable Google Images extractor workflow in your Python or Node.js stack.

### Use cases

| Use case name | Description |
| --- | --- |
| AI/ML dataset creation | Build large, diverse image metadata corpora by keyword to seed model training or labeling pipelines. |
| Visual SEO analysis | Track SERP image placements and extract titles, origins, and content URLs for trend analysis and optimization. |
| Brand monitoring | Discover where logos and product imagery appear online by collecting origin domains at scale. |
| E-commerce enrichment | Gather product-related visuals and source pages to support cataloging and competitive research. |
| Academic & market research | Collect structured Google Images metadata for studies, reports, and exploratory analysis. |
| API pipeline integration | Call the actor via Apify API in scheduled or event-driven workflows to feed BI tools or storage. |

### Why choose Google Images Scraper?

This production-ready Google Images crawler focuses on reliability, scale, and clean metadata output.

- 🎯 Accurate extraction logic that merges embedded data and link-based results for higher coverage.
- 🚀 Scales per query with smart pagination and infinite-scroll merging while avoiding duplicates.
- 🔌 API-ready for Google Images scraping API use, with easy integration into Python or Node.js pipelines.
- 🔐 Optional Apify Proxy support to handle tougher networks and reduce verification interruptions.
- 🧱 Stable infrastructure with headless Playwright and controlled retries for consistent runs.
- 💾 Real-time or batch saves so you can monitor live or push everything at the end — your choice.
- 🧰 Better than brittle extensions: no browser plugins or manual steps, just repeatable automation.

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

Yes — when used responsibly. This actor collects publicly available metadata (e.g., image URLs, titles, source pages, and origins) from Google Images results. It does not require login and does not access private or authenticated content.

Guidelines:
- Only use publicly available data and respect Google’s Terms of Service.
- Comply with data protection laws (e.g., GDPR, CCPA) and your organization’s policies.
- If you intend to download or reuse images, ensure you have permission or rely on fair-use and proper licensing.
- Consult your legal team for edge cases or commercial use.

### Input parameters & output format

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

Input fields

- queries (array, required)
  - Description: List of search phrases. One query per line in the editor.
  - Default: \["nature"]
- maxImages (integer)
  - Description: Cap how many unique images to keep for each keyword (1–1000).
  - Minimum: 1; Maximum: 1000
  - Default: 10
- proxyConfiguration (object)
  - Description: Pick proxy groups/countries in the picker. When enabled, the actor uses your selection for the browsing session.
  - Default: {"useApifyProxy": false}
- headless (boolean)
  - Description: On (default): best for Apify cloud. Off: useful for debugging locally.
  - Default: true
- pushToDatasetRealtime (boolean)
  - Description: ON: each image is pushed to the dataset immediately. OFF: everything uploads once at the end.
  - Default: true

Example JSON output

```json
[
  {
    "query": "nature",
    "imageUrl": "https://example.com/images/forest.jpg",
    "title": "Misty forest at sunrise",
    "imageWidth": 1600,
    "imageHeight": 1200,
    "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:EXAMPLE",
    "thumbnailWidth": 300,
    "thumbnailHeight": 200,
    "contentUrl": "https://example.com/blog/misty-forest",
    "origin": "example.com"
  }
]
```

Notes:

- The actor pushes each record to the dataset with the exact keys above.
- Width and height may be 0 if the result does not include dimensions.
- Export your dataset to JSON, CSV, or Excel from the Apify UI or API.

### FAQ

#### Does this tool download images or just collect URLs and metadata?

It collects image URLs, thumbnails, titles, source pages, and site origins. You can then use those URLs with a separate automated Google image downloader if you need the actual files.

#### How many images per query can it collect?

You control this with maxImages. The allowed range is 1–1000 per query. The actor uses pagination and scrolling to approach your target.

#### Can I stream results live to the Output dataset?

Yes. Set pushToDatasetRealtime to true to push each image immediately. Set it to false to upload all records in one batch at the end.

#### Does it support proxies?

Yes. Use proxyConfiguration to enable Apify Proxy. This helps when you encounter rate limits, blocks, or geo checks while you scrape Google Images results.

#### What fields are included in the output?

Each record includes: query, imageUrl, title, imageWidth, imageHeight, thumbnailUrl, thumbnailWidth, thumbnailHeight, contentUrl, and origin.

#### Is this a Google Images scraping API?

This is an Apify actor that you can run via the Apify API, making it suitable for use as a Google Images scraping API endpoint in your workflows.

#### Is it built with Python or Node.js?

The actor is implemented with Python and Playwright under the hood, but you can trigger it from any stack (including Node.js) using the Apify API.

#### What happens if Google challenges or blocks a request?

The actor detects challenge pages and logs a warning. You can enable Apify Proxy for better resilience and rerun the query. It also includes retry logic per query.

### Closing CTA / Final thoughts

Google Images Scraper is built to automate Google image search extraction into clean, structured datasets. With real-time streaming, optional Apify Proxy, and stable Playwright automation, it’s ideal for marketers, developers, analysts, and researchers who need image URLs, thumbnails, and source metadata at scale. Integrate it via the Apify API to power your Google Images extractor workflows in Python or Node.js — and start extracting smarter, faster, and more reliably today.

# 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("scrapapi/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("scrapapi/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 scrapapi/google-images-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Images Scraper",
        "description": "Extract image results from Google Images using the Google Images Scraper. Collect image URLs, titles, source websites, thumbnails, and search result data automatically. Ideal for research, dataset creation, SEO analysis, and visual content discovery.",
        "version": "0.1",
        "x-build-id": "XGd7LyqDiGe5MGJVu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~google-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~google-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~google-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```