# Google Maps Photos Scraper (`fetch_cat/google-maps-photos-scraper`) Actor

Extract public photo URLs and metadata from Google Maps places and search results.

- **URL**: https://apify.com/fetch\_cat/google-maps-photos-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.82 / 1,000 photo extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Maps Photos Scraper

Google Maps Photos Scraper collects public **Google Maps photos** for local SEO, hospitality, retail, and lead-generation workflows, exporting image URLs and place metadata from Google Maps.

### What does Google Maps Photos Scraper do?

Google Maps Photos Scraper exports public Google Maps photo URLs and visible Google Maps place metadata from Google Maps place pages and search results. It helps local SEO, hospitality, retail, and lead-generation teams collect public place-image references for media audits, competitor research, and visual reputation monitoring.

### Who is it for? Common use cases

- Local SEO agencies auditing business profile photo coverage
- Hospitality, restaurant, and retail teams monitoring public place media
- Lead generation teams enriching place lists with visual signals
- Reputation/media auditors comparing competitor photos by location
- Analysts building datasets of public Maps photo links for review

### What data can it export?

- Public Google-hosted photo URLs and thumbnail URLs
- Place name and resolved Google Maps URL
- Query or URL that produced each record
- Photo order/rank, visible dimensions, captions, and contributor labels when shown
- Google Maps identifiers when present in the public URL

### Input example

#### Single landmark or business

```json
{
  "queries": ["Statue of Liberty National Monument"],
  "maxPhotosPerPlace": 10,
  "includeSearchDiscovery": true,
  "maxConcurrency": 1,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

#### Category and location monitoring

```json
{
  "queries": ["pizza near Times Square New York"],
  "maxPhotosPerPlace": 25,
  "includeSearchDiscovery": true,
  "maxConcurrency": 1
}
```

#### Existing Google Maps URLs

```json
{
  "startUrls": [
    { "url": "https://www.google.com/maps/search/Eiffel+Tower" }
  ],
  "maxPhotosPerPlace": 10
}
```

### Example output

```json
{
  "placeName": "Statue of Liberty",
  "placeUrl": "https://www.google.com/maps/place/...",
  "placeId": "0x89c25090129c363d:0x40c6a5770d25022b",
  "cid": null,
  "query": "Statue of Liberty National Monument",
  "rank": 1,
  "photoUrl": "https://lh3.googleusercontent.com/...=w2048-h2048-k-no",
  "thumbnailUrl": "https://lh3.googleusercontent.com/...=w408-h544-k-no",
  "imageWidth": 408,
  "imageHeight": 544,
  "category": null,
  "caption": "Photo of Statue of Liberty",
  "contributorName": null,
  "scrapedAt": "2026-07-10T10:00:00.000Z"
}
```

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Google Maps place URLs or search URLs. |
| `queries` | array | Place names or category + location searches. |
| `maxPhotosPerPlace` | integer | Maximum photo records to save per input. |
| `includeSearchDiscovery` | boolean | Include visible search-result thumbnails before a result resolves to a single place. |
| `maxConcurrency` | integer | Browser pages in parallel; keep low for Google Maps reliability. |
| `proxyConfiguration` | object | Optional Apify Proxy settings. Start without proxy or with datacenter; use residential only if your run is blocked. |

### Output fields

| Field | Description |
| --- | --- |
| `placeName` | Visible Google Maps place name when available. |
| `placeUrl` | Resolved Maps URL used for extraction. |
| `placeId`, `cid` | Google Maps identifiers when present in the URL. |
| `query` | Query that produced the record, if any. |
| `rank` | Photo order within the input page. |
| `photoUrl` | Normalized public photo URL. |
| `thumbnailUrl` | Thumbnail URL visible in Google Maps. |
| `imageWidth`, `imageHeight` | Visible image dimensions when available. |
| `category` | Visible album/category label when available. |
| `caption` | Visible alt text or aria label when available. |
| `contributorName` | Public contributor/owner label when visible. |
| `scrapedAt` | ISO timestamp for the scrape. |

### Pricing

This actor uses pay-per-event pricing:

- Run start: **$0.005** per run
- Photo records: **$0.006 per photo record on the BRONZE tier**

Tier labels and per-photo prices:

| Tier | Price per photo |
| --- | ---: |
| Free | $0.00690 |
| Bronze | $0.00600 |
| Silver | $0.00468 |
| Gold | $0.00360 |
| Platinum | $0.00240 |
| Diamond | $0.00168 |

For quick estimates, 1,000 photo records cost about **$6.00** plus the small start fee on BRONZE.

### Tips for best results

- Use specific place names with city/location, such as `Hotel Chelsea New York`.
- For category monitoring, use queries such as `coffee shops near Shibuya Tokyo` and keep `includeSearchDiscovery` enabled.
- Keep `maxPhotosPerPlace` low for first tests, then scale after confirming output quality.
- If Google blocks requests in your region, enable Apify Proxy in the input.

### Limits and legality

This actor extracts only public Google Maps photo URLs and visible public metadata. It does not log in, bypass paywalls, download private content, or collect hidden account data. Always use the results according to Google Maps terms, privacy rules, and your local laws.

### Verified public example tasks

These Apify Store tasks use small, QA-verified inputs and can be opened or cloned directly:

- [Compare Nyc Landmark Google Maps Photos](https://apify.com/fetch_cat/google-maps-photos-scraper/tasks/compare-nyc-landmark-google-maps-photos) — verified run `ZhBj7JowEZ4JjwaSW` produced 6 dataset items.
- [Find Pizza Photos Near Times Square](https://apify.com/fetch_cat/google-maps-photos-scraper/tasks/find-pizza-photos-near-times-square) — verified run `zA3BdKsSFGZFzA1UH` produced 10 dataset items.
- [Scrape Eiffel Tower Place Photos](https://apify.com/fetch_cat/google-maps-photos-scraper/tasks/scrape-eiffel-tower-place-photos) — verified run `4ulaObBIcZK0mFJhR` produced 3 dataset items.
- [Scrape Statue Of Liberty Google Maps Photos](https://apify.com/fetch_cat/google-maps-photos-scraper/tasks/scrape-statue-of-liberty-google-maps-photos) — verified run `SNbKdQr9Q26O2OsrI` produced 1 dataset item.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-maps-photos-scraper').call({
  queries: ['Statue of Liberty National Monument'],
  maxPhotosPerPlace: 10
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/google-maps-photos-scraper').call(run_input={
    'queries': ['Statue of Liberty National Monument'],
    'maxPhotosPerPlace': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~google-maps-photos-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["Statue of Liberty National Monument"],"maxPhotosPerPlace":10}'
```

### MCP and agent usage

Use this actor from agents through Apify MCP:

```text
https://mcp.apify.com/?tools=fetch_cat/google-maps-photos-scraper
```

Claude CLI example:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/google-maps-photos-scraper
```

JSON configuration example:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/google-maps-photos-scraper"
    }
  }
}
```

Example prompts:

- "Collect public Google Maps photos for these five hotel URLs."
- "Find visible photo thumbnails for pizza places near Times Square."
- "Export Maps photo URLs for this landmark query as JSON."

### Related actors

- [Google Maps Reviews Scraper](https://apify.com/fetch_cat/google-maps-reviews-scraper)
- [Google Maps Lead Finder](https://apify.com/fetch_cat/google-maps-lead-finder)
- [Google Autocomplete Scraper](https://apify.com/fetch_cat/google-autocomplete-scraper)
- [Google Search Results Scraper](https://apify.com/fetch_cat/google-search-results-scraper)

### FAQ

**Does it download image files?**\
No. It exports public image URLs and thumbnails; you can download files separately if your use case allows it.

**Can it scrape private photos?**\
No. Only public Google Maps media visible without login is in scope.

**Why are some fields empty?**\
Google Maps does not expose every label, contributor, or category in every visible page state. Empty optional fields mean the value was not public/visible during the run.

### Support

If you need help, open an issue on the Apify actor page and include:

- Input JSON you used
- Expected output
- Actual output or dataset sample
- Reproducible public URL (for example, a public Google Maps URL) or query
- Run ID and error message, if any

### Changelog

- 2026-07-16 - Feature: Added ready-to-run example tasks on the Apify Store

- 2026-07-16 - Feature: Launched google maps photos scraper for public Apify Store users.

# Actor input Schema

## `startUrls` (type: `array`):

Public Google Maps place URLs or search result URLs to inspect for visible place photos.

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

Place names or category + location searches, for example `pizza near Times Square New York`.

## `maxPhotosPerPlace` (type: `integer`):

Maximum number of photo records to save from each URL or query.

## `includeSearchDiscovery` (type: `boolean`):

When enabled, search pages can return visible place/result thumbnails even before a single place is selected.

## `maxConcurrency` (type: `integer`):

Number of browser pages to run in parallel. Keep low for Google Maps reliability.

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

Optional Apify Proxy settings. Datacenter proxy is usually enough for testing; use residential only when Google blocks your run.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/search/Statue+of+Liberty+National+Monument"
    }
  ],
  "queries": [
    "Statue of Liberty National Monument"
  ],
  "maxPhotosPerPlace": 10,
  "includeSearchDiscovery": true,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.google.com/maps/search/Statue+of+Liberty+National+Monument"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-maps-photos-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 = { "startUrls": [{ "url": "https://www.google.com/maps/search/Statue+of+Liberty+National+Monument" }] }

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/google-maps-photos-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 '{
  "startUrls": [
    {
      "url": "https://www.google.com/maps/search/Statue+of+Liberty+National+Monument"
    }
  ]
}' |
apify call fetch_cat/google-maps-photos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Photos Scraper",
        "description": "Extract public photo URLs and metadata from Google Maps places and search results.",
        "version": "0.1",
        "x-build-id": "kxDpikDUtezToi10y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~google-maps-photos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-google-maps-photos-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/fetch_cat~google-maps-photos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-google-maps-photos-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/fetch_cat~google-maps-photos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-google-maps-photos-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",
                "properties": {
                    "startUrls": {
                        "title": "Google Maps place or search URLs",
                        "type": "array",
                        "description": "Public Google Maps place URLs or search result URLs to inspect for visible place photos.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Place names or category + location searches, for example `pizza near Times Square New York`.",
                        "default": [
                            "Statue of Liberty National Monument"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPhotosPerPlace": {
                        "title": "Max photos per input",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of photo records to save from each URL or query.",
                        "default": 10
                    },
                    "includeSearchDiscovery": {
                        "title": "Include search result thumbnails",
                        "type": "boolean",
                        "description": "When enabled, search pages can return visible place/result thumbnails even before a single place is selected.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Number of browser pages to run in parallel. Keep low for Google Maps reliability.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Datacenter proxy is usually enough for testing; use residential only when Google blocks your run.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
