# Amazon Autocomplete Actor (`solid-scraper/amazon-autocomplete-actor`) Actor

🤖 Streamline lead research with this Amazon Autocomplete Actor! 🚀 Automatically fetches product suggestions and search insights to power smarter keyword research and faster listings. Perfect for SEO, sellers, and eCommerce teams. 📈

- **URL**: https://apify.com/solid-scraper/amazon-autocomplete-actor.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** E-commerce, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Amazon Autocomplete Scraper 🔍

**Amazon Autocomplete Scraper** fetches Amazon autocomplete suggestions for a given search term, helping you extract search keywords quickly instead of manually typing and guessing. If you’re looking for an **Amazon autocomplete scraper**, an **Amazon autocomplete keyword extractor**, or an **Amazon autosuggest scraper**, this actor streamlines “scrape Amazon autocomplete suggestions” workflows for marketers, researchers, and SEO teams. Whether you’re building keyword lists, planning content topics, or doing quick discovery for product and demand research, it enables you to collect relevant autocomplete terms at scale—saving you hours of manual work.

### Why choose Amazon Autocomplete Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ All-in-one autocomplete collection | Collects suggestions for your query and (optionally) prefixed/suffixed variants in one run |
| ✅ Reliability with resilient fetching | Includes safeguards so failures for one query don’t break the entire job |
| ✅ Structured output | Returns consistent records where each suggestion is stored in clearly labeled fields |
| ✅ Scales across multiple suggestion sets | Generates additional query variants when `use_prefix` and/or `use_suffix` are enabled |
| ✅ Simple automation-friendly input | Uses straightforward parameters like `query` and `max_results` for repeatable keyword research runs |
| ✅ Export-ready dataset | Saves results directly into an Apify dataset for easy export to JSON/CSV |

### Key features

- 🔤 **Keyword autocomplete scraping**: Pulls suggestion terms from Amazon autocomplete for your provided `query`
- 📈 **Max results control**: Limits returned suggestions per query using `max_results`
- 🧩 **Optional prefix expansion**: When enabled, generates additional queries by adding alphabetic prefixes before your `query`
- 🧩 **Optional suffix expansion**: When enabled, generates additional queries by adding alphabetic suffixes after your `query`
- 🛡️ **Resilient fetching**: Handles request issues gracefully and continues processing other queries
- 📦 **Clean, structured dataset**: Stores each run’s results as JSON records with predictable field naming for suggestions
- 💾 **Automation-ready output**: Pushes results to the default dataset so you can plug it into downstream analysis

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "query": "apple watch",
  "max_results": 10,
  "use_prefix": false,
  "use_suffix": false
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `query` | Yes | The search term to get suggestions for (for example, a product category, brand, or intent phrase). |
| `max_results` | No | The maximum number of suggestions to return for each query. |
| `use_prefix` | No | Whether to add alphabetic prefixes to the query to generate additional autocomplete keyword research inputs. |
| `use_suffix` | No | Whether to add alphabetic suffixes to the query to generate additional autocomplete keyword research inputs. |

### Output

The actor saves results as JSON records in the default dataset.

```json
[
  {
    "query": "apple watch",
    "suggestion_01": "apple watch series",
    "suggestion_02": "apple watch bands",
    "suggestion_03": "apple watch se",
    "suggestion_04": "apple watch buy",
    "suggestion_05": "apple watch size"
  }
]
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | The query text used to fetch suggestions |
| `suggestion_01` | string | The first autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_02` | string | The second autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_03` | string | The third autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_04` | string | The fourth autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_05` | string | The fifth autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_06` | string | The sixth autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_07` | string | The seventh autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_08` | string | The eighth autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_09` | string | The ninth autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_10` | string | The tenth autocomplete suggestion for the `query` (up to `max_results`) |
| `suggestion_11` | string | Not included in output because results are capped to `max_results` (the fetch request internally requests more than `max_results`) |

> Note: The actor returns `suggestion_01`…`suggestion_10` depending on your `max_results` value.

After export, you can easily move the dataset into spreadsheets, BI tools, or further keyword research steps (for example, combining the output with your existing lists and filtering).

### How to use Amazon Autocomplete Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and go to the **Actors** section.

2. **Find the actor**\
   Search for **Amazon Autocomplete Scraper** and open the actor page.

3. **Go to the INPUT section**\
   You’ll see a form corresponding to the input schema fields:
   - `query`
   - `max_results`
   - `use_prefix`
   - `use_suffix`

4. **Set your query and limits**\
   Enter the search term in `query`, and choose how many suggestions you want per query using `max_results` (default is `10`).

5. **Optionally enable prefix/suffix keyword expansion**\
   Turn on `use_prefix` to generate additional autocomplete keyword research queries by adding alphabetic prefixes.\
   Turn on `use_suffix` to generate additional queries by adding alphabetic suffixes.

6. **Run the actor**\
   Click **Run**. During execution, you can monitor logs for progress updates.

7. **Open results in the OUTPUT tab**\
   After the run completes, open the default dataset in the **OUTPUT** tab to view/export your JSON results (JSON or CSV).

No coding required—get Amazon autocomplete keyword tool results in minutes. 🚀

### Advanced features & SEO optimization

- 🧠 **Engineered for Amazon autocomplete keyword research**: Built to help you extract Amazon autocomplete search terms for SEO discovery and ideation using an **Amazon autocomplete API scraper**-style workflow.
- 🔁 **Expandable keyword coverage**: With `use_prefix` and `use_suffix`, you can scrape Amazon autocomplete suggestions for more query variations in a single run.
- 📊 **Structured suggestion fields for analysis**: The output is organized so you can quickly analyze or deduplicate terms extracted from autocomplete suggestions.
- 💾 **Scale-friendly dataset output**: Results are pushed into the dataset immediately after collection, making it easy to automate downstream keyword processing.

### Best use cases

- 🎯 **SEO specialist keyword ideation**: Quickly compile new content targets by extracting Amazon autocomplete keyword tool suggestions for seed topics.
- 🛒 **Ecommerce product research**: Discover how shoppers phrase demand by scraping Amazon autosuggest terms related to product categories like “apple watch”.
- 📣 **Performance marketer campaign planning**: Build keyword lists from an Amazon autocomplete scraper tool output and map terms to ad groups or landing pages.
- 🔎 **Market researcher topic discovery**: Extract Amazon autocomplete keyword extractor results to understand what users might be searching for in different phrasing.
- 🧾 **Data analyst keyword normalization workflows**: Programmatically scrape Amazon autocomplete suggestions and run cleanup/deduping in your pipeline.
- 💡 **Content strategist search intent mapping**: Use suggestion sequences to infer common intent patterns and write content briefs faster.
- 🧱 **Automations and enrichment pipelines**: Feed extracted Amazon suggestion scraper outputs into your existing keyword research stack or CRM-style datasets.

### Technical specifications

- **Supported Input Formats**
  - ✅ `query` (string)
  - ✅ `max_results` (integer)
  - ✅ `use_prefix` (boolean)
  - ✅ `use_suffix` (boolean)

- **Proxy Support**
  - ❌ No proxy configuration is exposed in the actor input schema provided.

- **Retry Mechanism**
  - ✅ Resilient fetching: request failures for a query are handled so the job can continue.

- **Dataset Structure**
  - ✅ Default dataset with JSON records containing `query` and `suggestion_01`…`suggestion_N` (based on `max_results`)

- **Rate Limits & Performance**
  - ✅ Designed for repeatable runs; performance varies based on response times from publicly available sources.

- **Limitations**
  - ❌ The actor does not output additional metadata beyond the fields shown (it only returns `query` and `suggestion_*` terms).

### FAQ

#### What does the Amazon Autocomplete Scraper return?

✅ It returns a JSON dataset where each record contains your `query` plus suggestion fields named `suggestion_01`, `suggestion_02`, and so on, up to your `max_results`.

#### Can I control how many autocomplete suggestions I get?

✅ Yes. Use `max_results` to set the maximum number of suggestions returned for each query.

#### How do `use_prefix` and `use_suffix` work?

✅ If you enable `use_prefix`, the actor generates additional queries by adding alphabetic prefixes before your `query`. If you enable `use_suffix`, it generates additional queries by adding alphabetic suffixes after your `query`.

#### Is this an “Amazon search suggestions scraper” or an “Amazon autocomplete keyword extractor”?

✅ Both in practice. The actor programmatically scrapes Amazon autocomplete suggestions and outputs them in a structured format that works like an **Amazon autocomplete keyword extractor** for your keyword research workflow.

#### Do I need coding to run Amazon Autocomplete Scraper?

✅ No. You can run it directly in Apify Console by filling in the input form.

#### Does it require login or special API keys?

❌ Nothing in the provided actor specification indicates you need login credentials or API keys as part of the input schema.

#### What output format is produced?

✅ The actor saves results as JSON records in the default dataset, and you can export to formats like CSV from the Apify dataset UI.

#### Is it legal to use autocomplete suggestions for keyword research?

✅ This tool works with **publicly available sources**. You’re responsible for complying with applicable laws (for example GDPR/CCPA), spam regulations, and platform terms when you use the data.

### Support & feature requests

Have questions or want improvements to **Amazon Autocomplete Scraper**? 💬 We’re happy to hear from you.

- 💡 **Feature Requests**: Examples include adding CSV-friendly fields, exporting additional transformations (like deduping or normalization), or enhancing integration steps for downstream keyword research tooling.
- 📧 **Contact**: For support or feedback, email <dataforleads@gmail.com>.

Your feedback helps shape future updates to make this Amazon autocomplete scraper tool even more useful. 🚀

### Closing CTA / Final thoughts

*If you need the most comprehensive, SEO-optimized way to scrape Amazon autocomplete suggestions, Amazon Autocomplete Scraper is a fast path from seed terms to structured keyword research data.*

### Disclaimer

This tool only accesses **publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for complying with applicable laws (including GDPR/CCPA where relevant), spam regulations, and the platform’s terms of service when you use the extracted data.

For data removal requests, contact <dataforleads@gmail.com>.

Use **Amazon Autocomplete Scraper** responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `query` (type: `string`):

The search term to get suggestions for.

## `max_results` (type: `integer`):

The maximum number of suggestions to return for each query.

## `use_prefix` (type: `boolean`):

Whether to add alphabetic prefixes to the query.

## `use_suffix` (type: `boolean`):

Whether to add alphabetic suffixes to the query.

## Actor input object example

```json
{
  "query": "apple watch",
  "max_results": 10,
  "use_prefix": false,
  "use_suffix": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/amazon-autocomplete-actor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/amazon-autocomplete-actor").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 '{}' |
apify call solid-scraper/amazon-autocomplete-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Autocomplete Actor",
        "description": "🤖 Streamline lead research with this Amazon Autocomplete Actor! 🚀 Automatically fetches product suggestions and search insights to power smarter keyword research and faster listings. Perfect for SEO, sellers, and eCommerce teams. 📈",
        "version": "1.0",
        "x-build-id": "GcpUyLHpI2nqueTgc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~amazon-autocomplete-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-amazon-autocomplete-actor",
                "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/solid-scraper~amazon-autocomplete-actor/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-amazon-autocomplete-actor",
                "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/solid-scraper~amazon-autocomplete-actor/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-amazon-autocomplete-actor",
                "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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "The search term to get suggestions for.",
                        "default": "apple watch"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "type": "integer",
                        "description": "The maximum number of suggestions to return for each query.",
                        "default": 10
                    },
                    "use_prefix": {
                        "title": "Use Prefix",
                        "type": "boolean",
                        "description": "Whether to add alphabetic prefixes to the query.",
                        "default": false
                    },
                    "use_suffix": {
                        "title": "Use Suffix",
                        "type": "boolean",
                        "description": "Whether to add alphabetic suffixes to the query.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
