# Pinterest Autocomplete Actor (`solid-scraper/pinterest-autocomplete-actor`) Actor

🎬 Discover top “Actor” search ideas on Pinterest! Find trending roles, audition keywords, and content inspiration to boost your reach. 🚀 Perfect for actors, casting creatives, and social media growth—start exploring autocomplete today!

- **URL**: https://apify.com/solid-scraper/pinterest-autocomplete-actor.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Social media, Lead generation, SEO tools
- **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

### Pinterest Autocomplete Scraper 🔍

**Pinterest Autocomplete Scraper** helps you extract Pinterest autocomplete suggestions for a given query—so you can do faster keyword research, discover related search intent, and build richer content ideas without manually typing every variation. Whether you’re using a **Pinterest autocomplete scraper**, a **Pinterest search autocomplete scraper**, or a **Pinterest suggestion scraper**, this actor turns autocomplete mining into structured, reusable data for marketers, analysts, and researchers—saving you hours of manual work.

---

### Why choose Pinterest Autocomplete Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Autocomplete suggestions for your query** | Quickly gathers Pinterest autocomplete keyword data for a specific search term |
| ✅ **Max results control** | Limits how many suggestions you store per query with `max_results` |
| ✅ **Optional prefix and suffix expansion** | Helps explore additional Pinterest autocomplete terms around your original query |
| ✅ **Built-in resilience for scraping requests** | Includes fallbacks (returns empty suggestions on request failures) so runs complete reliably |
| ✅ **Structured JSON output** | Produces consistent records with `query` and `suggestion_XX` fields |
| ✅ **Ready for automation workflows** | Easy to run in batches and export the dataset as JSON/CSV |

---

### Key features

- 🔍 **Autocomplete keyword suggestions**: Fetches suggestion text for your provided search term
- 🧩 **Query variation mining**: Optionally uses prefix and/or suffix variations to expand discovery beyond the original phrase
- 🎯 **Configurable result limit**: Stores only up to `max_results` suggestions per query in the output
- 🛡️ **Resilient request handling**: Handles request failures gracefully and continues the run
- 📦 **Consistent dataset structure**: Each record includes the original (or expanded) `query` and numbered `suggestion_XX` fields
- 💾 **Dataset export friendly**: Saves results to the default dataset, ready to export for analysis
- 🔄 **Scales across multiple expanded queries**: Automatically generates additional queries when prefix/suffix options are enabled

---

### 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 you want suggestions for (e.g., a keyword for Pinterest autocomplete keyword research). |
| `max_results` | No | The maximum number of suggestions to return for each query. This controls how many `suggestion_XX` fields get filled. |
| `use_prefix` | No | Whether to add alphabetic prefixes to your query (useful for scraping broader Pinterest autocomplete terms). |
| `use_suffix` | No | Whether to add alphabetic suffixes to the query (useful for finding more Pinterest related search suggestions). |

***

### Output

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

Example output for one run:

```json
[
  {
    "query": "apple watch",
    "suggestion_01": "apple watch series",
    "suggestion_02": "apple watch bands",
    "suggestion_03": "apple watch watch faces"
  },
  {
    "query": "a apple watch",
    "suggestion_01": "apple watch series a",
    "suggestion_02": "apple watch bands a"
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `query` | string | The original query or an expanded query (when prefixes/suffixes are enabled). |
| `suggestion_01` | string | The first autocomplete suggestion for the given `query` (up to `max_results`). |
| `suggestion_02` | string | The second autocomplete suggestion for the given `query`. |
| `suggestion_03` | string | The third autocomplete suggestion for the given `query`. |
| `suggestion_04` | string | The fourth autocomplete suggestion for the given `query`. |
| `suggestion_05` | string | The fifth autocomplete suggestion for the given `query`. |
| `suggestion_06` | string | The sixth autocomplete suggestion for the given `query`. |
| `suggestion_07` | string | The seventh autocomplete suggestion for the given `query`. |
| `suggestion_08` | string | The eighth autocomplete suggestion for the given `query`. |
| `suggestion_09` | string | The ninth autocomplete suggestion for the given `query`. |
| `suggestion_10` | string | The tenth autocomplete suggestion for the given `query` (if `max_results` is 10 or higher). |
| `error_message` | string | ❌ Not present in the actor output (this actor returns empty suggestion lists on request failures rather than outputting an error field). |

**Note:** The dataset is stored as JSON records and can typically be exported from Apify Console to formats like JSON/CSV depending on your workflow.

***

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

1. **Open Apify Console**\
   Go to [console.apify.com](https://console.apify.com) and log in.

2. **Find the actor**\
   Search for **Pinterest Autocomplete Scraper** in the Actors marketplace.

3. **Open the INPUT panel**\
   In the actor’s page, locate the **INPUT** section and click to expand it.

4. **Enter your settings**\
   Fill in:
   - `query` (required)
   - `max_results` (optional, defaults to 10)
   - `use_prefix` (optional, defaults to false)
   - `use_suffix` (optional, defaults to false)

5. **(Optional) Expand suggestion coverage**\
   If you want more Pinterest autocomplete keyword scraper output beyond the original phrase, enable `use_prefix` and/or `use_suffix`.

6. **Run the actor**\
   Click **Run**. During execution, you can watch the logs to see suggestions being collected for each query variation.

7. **Open the OUTPUT dataset**\
   After the run finishes, open the default dataset from the **OUTPUT** tab.

8. **Export results**\
   Export the dataset to JSON/CSV for keyword research, content planning, or building a Pinterest autocomplete mining tool pipeline.

No coding required—get accurate Pinterest autocomplete suggestions in minutes. 🚀

***

### Advanced features & SEO optimization

- ✨ **Engineered for Pinterest autocomplete keyword research**: Designed specifically to extract autocomplete suggestions—great for “Pinterest autocomplete text scraper” style workflows without manual copy-paste.
- 🔎 **Broader term discovery**: Use `use_prefix` / `use_suffix` to scrape additional Pinterest autocomplete terms and related suggestions.
- 📊 **Structured data for analysis**: Output consistently uses `query` plus numbered suggestion fields (e.g., `suggestion_01`, `suggestion_02`) for easy spreadsheet/CRM ingestion.
- 🧠 **Resilient runs with safe fallbacks**: When requests fail, the actor returns empty suggestions for that query and continues processing the rest.
- 📝 **Keyword intent at scale**: Helps you turn a single seed keyword into a larger set of Pinterest search bar suggestions for faster ideation.

***

### Best use cases

- 📈 **Content marketing keyword research**: Turn one seed keyword into a list of Pinterest autocomplete keyword scraper suggestions for blog pins and campaign ideas.
- 🧠 **SEO and semantic research**: Collect Pinterest autocomplete terms to map search intent and expand topic clusters.
- 🏷️ **Brand and category exploration**: Discover related suggestion mining results for a niche to find new angles in your Pinterest related search strategy.
- 🎯 **Ad creative testing**: Generate variations from Pinterest autocomplete data extraction to test new hooks, titles, and pin descriptions.
- 💼 **B2B research and analysis workflows**: Feed Pinterest suggestion scraper outputs into analytics notebooks or dashboards for trend tracking.
- 🤖 **Automation pipelines**: Use the Pinterest autocomplete API alternatives-style dataset structure to integrate into your existing data processing jobs.

***

### Technical specifications

**Supported Input Formats**

- ✅ `query` as a string (required)
- ✅ `max_results` as an integer (optional)
- ✅ `use_prefix` as a boolean (optional)
- ✅ `use_suffix` as a boolean (optional)

**Proxy Support**

- ✅ Apify runtime support for reliable scraping workflows is available at a high level (no actor-specific proxy parameters in the provided input schema).

**Retry Mechanism**

- ✅ Includes fallbacks for resilience (request failures result in empty suggestion lists for that query, and the run continues).

**Dataset Structure**

- ✅ The actor pushes an array of records to the default dataset via `await Actor.push_data(all_suggestions)`.
- ✅ Each record includes `query` and numbered `suggestion_XX` fields for up to `max_results`.

**Rate Limits & Performance**

- ⚠️ Performance depends on network conditions and how many expanded queries you generate with prefixes/suffixes.

**Limitations**

- ❌ No explicit `error_message` output field is produced by this actor.
- ❌ If the underlying request fails for a query, suggestions for that query will be empty.

***

### FAQ

#### Does Pinterest Autocomplete Scraper require authentication or special login?

✅ No login input is required by the provided actor schema. You only provide `query` and optional settings like `max_results`, `use_prefix`, and `use_suffix`.

#### What does the actor return for each query?

✅ The actor returns one record per input query (and per expanded prefix/suffix query when enabled). Each record contains `query` and numbered fields like `suggestion_01`, `suggestion_02`, etc., up to your `max_results`.

#### Can I get more than one set of suggestions from a single run?

✅ Yes. If you enable `use_prefix` and/or `use_suffix`, the actor generates additional queries and collects suggestions for each one—useful for scraping broader Pinterest autocomplete terms.

#### How do I control how many suggestions I get?

✅ Use `max_results`. The actor slices suggestions to `suggestions[:max_results]` before saving them into `suggestion_01` … `suggestion_XX`.

#### Is the output suitable for spreadsheets and keyword research tools?

✅ Yes. The structured JSON records with consistent `suggestion_XX` fields make it straightforward to export and analyze as Pinterest autocomplete keyword scraper data.

#### Do you provide an error field in the dataset?

❌ No. The dataset structure shown by the source code includes `query` and suggestion fields; it does not define an `error_message` field in the output.

#### Can I export the results to CSV?

✅ After the run, you can export the dataset from Apify Console. The actor saves JSON records to the default dataset, which is typically exportable to formats like CSV depending on your console options.

#### Is it legal and compliant to use this actor’s data?

✅ The actor collects data from publicly available sources, but whether your use complies with applicable laws (including GDPR/CCPA), platform rules, and spam regulations is your responsibility.

***

### Support & feature requests

If you’re using **Pinterest Autocomplete Scraper** for Pinterest autocomplete scraping, I’d love to hear what you’re trying to achieve and where this could be improved.

- 💡 **Feature Requests**: Examples include adding different suggestion field naming, customizing result limits per expanded query, or improving export-friendly formats for Pinterest suggestion scraper workflows.
- 📧 **Contact**: For questions or feedback, email <dataforleads@gmail.com>.

Your feedback helps shape the next updates to this Pinterest autocomplete keyword scraper.

***

### Closing CTA / Final thoughts

*Get the most comprehensive Pinterest autocomplete suggestions with a clean, dataset-ready output format.* *If you’re looking for an SEO-optimized Pinterest Autocomplete Scraper, this actor is built to help you mine intent faster—at scale.*

***

### Disclaimer

This tool **only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected content. It is the user’s responsibility to comply with applicable laws (including GDPR/CCPA), spam regulations, and platform terms of service.

For data removal requests, contact <dataforleads@gmail.com>.\
Please use this actor 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/pinterest-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/pinterest-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/pinterest-autocomplete-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Autocomplete Actor",
        "description": "🎬 Discover top “Actor” search ideas on Pinterest! Find trending roles, audition keywords, and content inspiration to boost your reach. 🚀 Perfect for actors, casting creatives, and social media growth—start exploring autocomplete today!",
        "version": "1.0",
        "x-build-id": "cNARBHwTQU1xiPzmX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~pinterest-autocomplete-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-pinterest-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~pinterest-autocomplete-actor/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-pinterest-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~pinterest-autocomplete-actor/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-pinterest-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
