# Google Images Scraper — Original URLs, Source & Size (`khadinakbar/google-images-scraper`) Actor

Scrape Google Images by keyword: original full-resolution image URL, source page, thumbnail, title, dimensions, and product flag. Filter by size, type, color, and usage rights. Multi-query, 40+ countries. Managed SerpApi backend, HTTP-only, no login. MCP-ready.

- **URL**: https://apify.com/khadinakbar/google-images-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, MCP servers, SEO tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 image scrapeds

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 — Original URLs, Source & Size

Scrape **Google Images** by keyword and get back the **original full-resolution image URL**, the **source page**, a **thumbnail**, the **title**, **pixel dimensions**, and a **product flag** — as clean structured JSON. Multi-query, 40+ countries, with size / type / color / usage-rights filters. HTTP-only via a managed [SerpApi](https://serpapi.com/) backend, no login, no cookies, no browser. **MCP-ready** for AI agents.

### What it does

Give it one or more search keywords. For each query it returns up to 500 images, each as a flat record with the direct link to the original file plus the page it was found on — ready to download, dedupe, or feed into a dataset.

### When to use it

- Build **image datasets** for machine-learning / computer-vision training.
- Collect **product images** and competitor visuals for ecommerce.
- Source **design inspiration**, mood boards, and reference imagery at scale.
- Pull **press / brand imagery** for marketing and SEO research.
- Power an **AI agent** that needs to find images by description (MCP tool).

Do **not** use this to scrape a specific website's gallery (use a site crawler) or to bypass image licensing — see the legal note below.

### Output

One record per image:

| Field | Description |
|---|---|
| `query` | The search query the image was returned for |
| `position` | 1-based rank within the query |
| `title` | Image title / alt text |
| `imageUrl` | **Direct URL to the original full-resolution image** |
| `thumbnailUrl` | Small Google-hosted preview thumbnail |
| `sourceName` | Website hosting the image |
| `sourcePageUrl` | Page the image appears on |
| `originalWidth` / `originalHeight` | Pixel dimensions, when known |
| `isProduct` | `true` if Google tagged it as a shoppable product |
| `scrapedAt` | ISO 8601 timestamp |

```json
{
  "query": "golden retriever puppy",
  "position": 1,
  "title": "Golden Retriever Puppy sitting in grass",
  "imageUrl": "https://example.com/images/golden-retriever-puppy.jpg",
  "thumbnailUrl": "https://encrypted-tbn0.gstatic.com/images?q=tbn:...",
  "sourceName": "example.com",
  "sourcePageUrl": "https://example.com/puppies/golden-retriever",
  "originalWidth": 1920,
  "originalHeight": 1280,
  "isProduct": false,
  "scrapedAt": "2026-06-30T12:00:00.000Z"
}
````

### Pricing

Pay-per-event:

- **Actor start:** $0.00005 per run
- **Image scraped:** **$0.002 per image** returned

A 100-image query costs about **$0.20**. The cost cap is printed in the run log before any charge fires, and the actor never charges beyond `Max results per query × number of queries`.

### Input

| Field | Required | Default | Notes |
|---|---|---|---|
| `queries` | ✅ | — | List of keyword searches, e.g. `["golden retriever puppy"]` |
| `maxResultsPerQuery` | | `100` | 1–500, paginates automatically |
| `country` | | `us` | 2-letter ISO code (`gl`) |
| `language` | | `en` | 2-letter code (`hl`) |
| `safeSearch` | | `off` | `off` or `active` |
| `imageSize` | | `any` | `large` / `medium` / `icon` |
| `imageType` | | `any` | `photo` / `clipart` / `lineart` / `gif` / `face` |
| `imageColor` | | `any` | `color` / `grayscale` / `transparent` |
| `usageRights` | | `any` | `creativeCommons` / `commercial` |

#### Example input

```json
{
  "queries": ["vintage neon sign", "art deco poster"],
  "maxResultsPerQuery": 100,
  "country": "us",
  "imageType": "photo",
  "imageSize": "large"
}
```

### Use it from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~google-images-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["golden retriever puppy"],"maxResultsPerQuery":50}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/google-images-scraper").call(
    run_input={"queries": ["golden retriever puppy"], "maxResultsPerQuery": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["imageUrl"])
```

### MCP / AI agents

Exposed as `apify--google-images-scraper` in the Apify MCP server. Pass a keyword in, get structured image records out — ideal for agents that need to find or collect images by description.

### FAQ

**Do I need a SerpApi key?** No. The backend is fully managed — there is nothing to configure.

**How many images per query?** Up to 500. Google serves roughly 100 per page and the actor paginates automatically.

**Are the image URLs the originals or thumbnails?** `imageUrl` is the original full-resolution file. `thumbnailUrl` is the small Google preview.

**Why is an image's `imageUrl` sometimes null?** A small fraction of Google results omit the original; the thumbnail and source page are still returned.

### Legal

This actor returns links to publicly visible images and their source pages. It does **not** grant any license to those images. The `usageRights` filter reflects Google's labeling and is **not** legal clearance — you are responsible for verifying the license on each image's source page before downloading, reusing, or redistributing it. Use in compliance with Google's Terms of Service and applicable copyright law.

# Actor input Schema

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

One or more keyword searches run on Google Images (e.g. 'golden retriever puppy'). Each query is scraped independently and returns up to 'Max results per query' images. Accepts plain keywords; Google search operators like quotes and site: also work. NOT image URLs or page URLs — pass keywords only.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of images to return for each query (e.g. 100). Google Images serves roughly 100 images per page; higher values paginate automatically. Defaults to 100, hard-capped at 500. This is per query, so 3 queries at 100 yields up to 300 images.

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

Two-letter ISO country code for localized image results (e.g. 'us', 'gb', 'de', 'jp'). Maps to Google's 'gl' parameter and biases results to that region. Defaults to 'us'. NOT a full country name — use the 2-letter code.

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

Two-letter UI/result language code (e.g. 'en', 'es', 'fr'). Maps to Google's 'hl' parameter. Defaults to 'en'. NOT a country code — this controls language, 'country' controls region.

## `safeSearch` (type: `string`):

Whether Google's SafeSearch adult-content filter is applied. 'active' filters explicit imagery; 'off' returns unfiltered results. Defaults to 'off'. Set to 'active' for brand-safe or workplace use.

## `imageSize` (type: `string`):

Filter results by image dimensions. 'large' favors high-resolution images, 'icon' favors small ones, 'medium' is in between. Defaults to 'any' (no size filter). Use 'large' when you need print-quality originals.

## `imageType` (type: `string`):

Filter results by the kind of image. 'photo' returns photographs, 'clipart'/'lineart' return graphics, 'gif' returns animated images, 'face' returns headshots. Defaults to 'any'. Use 'face' for people, 'photo' to exclude illustrations.

## `imageColor` (type: `string`):

Filter results by dominant color profile. 'color' returns full-color images, 'grayscale' returns black-and-white, 'transparent' returns images with a transparent background. Defaults to 'any'. Use 'transparent' to find PNG cut-outs for design work.

## `usageRights` (type: `string`):

Filter by Google's reported licensing. 'creativeCommons' favors Creative Commons licenses, 'commercial' favors commercial & other licenses. Defaults to 'any'. Note: this reflects Google's labeling and is not a legal clearance — always verify the license on the source page before reuse.

## Actor input object example

```json
{
  "queries": [
    "golden retriever puppy",
    "vintage neon sign"
  ],
  "maxResultsPerQuery": 100,
  "country": "us",
  "language": "en",
  "safeSearch": "off",
  "imageSize": "any",
  "imageType": "any",
  "imageColor": "any",
  "usageRights": "any"
}
```

# Actor output Schema

## `images` (type: `string`):

No description

## `summary` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "golden retriever puppy"
    ],
    "maxResultsPerQuery": 100,
    "country": "us",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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": ["golden retriever puppy"],
    "maxResultsPerQuery": 100,
    "country": "us",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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": [
    "golden retriever puppy"
  ],
  "maxResultsPerQuery": 100,
  "country": "us",
  "language": "en"
}' |
apify call khadinakbar/google-images-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Images Scraper — Original URLs, Source & Size",
        "description": "Scrape Google Images by keyword: original full-resolution image URL, source page, thumbnail, title, dimensions, and product flag. Filter by size, type, color, and usage rights. Multi-query, 40+ countries. Managed SerpApi backend, HTTP-only, no login. MCP-ready.",
        "version": "0.1",
        "x-build-id": "uCttXQbnhGv3pKebo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~google-images-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~google-images-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~google-images-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": "Search queries",
                        "type": "array",
                        "description": "One or more keyword searches run on Google Images (e.g. 'golden retriever puppy'). Each query is scraped independently and returns up to 'Max results per query' images. Accepts plain keywords; Google search operators like quotes and site: also work. NOT image URLs or page URLs — pass keywords only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of images to return for each query (e.g. 100). Google Images serves roughly 100 images per page; higher values paginate automatically. Defaults to 100, hard-capped at 500. This is per query, so 3 queries at 100 yields up to 300 images.",
                        "default": 100
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter ISO country code for localized image results (e.g. 'us', 'gb', 'de', 'jp'). Maps to Google's 'gl' parameter and biases results to that region. Defaults to 'us'. NOT a full country name — use the 2-letter code.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter UI/result language code (e.g. 'en', 'es', 'fr'). Maps to Google's 'hl' parameter. Defaults to 'en'. NOT a country code — this controls language, 'country' controls region.",
                        "default": "en"
                    },
                    "safeSearch": {
                        "title": "SafeSearch",
                        "enum": [
                            "off",
                            "active"
                        ],
                        "type": "string",
                        "description": "Whether Google's SafeSearch adult-content filter is applied. 'active' filters explicit imagery; 'off' returns unfiltered results. Defaults to 'off'. Set to 'active' for brand-safe or workplace use.",
                        "default": "off"
                    },
                    "imageSize": {
                        "title": "Image size",
                        "enum": [
                            "any",
                            "large",
                            "medium",
                            "icon"
                        ],
                        "type": "string",
                        "description": "Filter results by image dimensions. 'large' favors high-resolution images, 'icon' favors small ones, 'medium' is in between. Defaults to 'any' (no size filter). Use 'large' when you need print-quality originals.",
                        "default": "any"
                    },
                    "imageType": {
                        "title": "Image type",
                        "enum": [
                            "any",
                            "photo",
                            "clipart",
                            "lineart",
                            "gif",
                            "face"
                        ],
                        "type": "string",
                        "description": "Filter results by the kind of image. 'photo' returns photographs, 'clipart'/'lineart' return graphics, 'gif' returns animated images, 'face' returns headshots. Defaults to 'any'. Use 'face' for people, 'photo' to exclude illustrations.",
                        "default": "any"
                    },
                    "imageColor": {
                        "title": "Image color",
                        "enum": [
                            "any",
                            "color",
                            "grayscale",
                            "transparent"
                        ],
                        "type": "string",
                        "description": "Filter results by dominant color profile. 'color' returns full-color images, 'grayscale' returns black-and-white, 'transparent' returns images with a transparent background. Defaults to 'any'. Use 'transparent' to find PNG cut-outs for design work.",
                        "default": "any"
                    },
                    "usageRights": {
                        "title": "Usage rights",
                        "enum": [
                            "any",
                            "creativeCommons",
                            "commercial"
                        ],
                        "type": "string",
                        "description": "Filter by Google's reported licensing. 'creativeCommons' favors Creative Commons licenses, 'commercial' favors commercial & other licenses. Defaults to 'any'. Note: this reflects Google's labeling and is not a legal clearance — always verify the license on the source page before reuse.",
                        "default": "any"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```