# Pinterest Trends Scraper (`automation-lab/pinterest-trends-scraper`) Actor

Extract Pinterest trend keywords, growth signals, seasonal scores, and market metadata for content, ecommerce, and ad research.

- **URL**: https://apify.com/automation-lab/pinterest-trends-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 6 total users, 4 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Pinterest Trends Scraper

Extract Pinterest trend keywords, growth signals, seasonal scores, and market metadata from Pinterest Trends.

Use this actor to discover what Pinterest users are searching for across supported countries and regions.

### What does Pinterest Trends Scraper do?

Pinterest Trends Scraper collects structured trend rows from Pinterest Trends.

It returns keywords, ranks, normalized search counts, growth changes, seasonality, country, trend type, and a Pinterest Trends URL.

The actor is built for content, ecommerce, social, and advertising research workflows.

### Who is it for?

#### Content marketers

Plan articles, landing pages, and seasonal calendars around rising Pinterest demand.

#### Ecommerce teams

Spot product and style trends before they peak.

#### Agencies

Build client reports for different countries and trend types.

#### SEO researchers

Find visual-search keyword ideas that are not obvious in traditional SEO tools.

#### Social media teams

Translate trend momentum into boards, pins, campaigns, and creative briefs.

### Why use this actor?

- 📈 Get trend keywords with growth metrics.
- 🌍 Compare countries and regional markets.
- 🔎 Filter by included or excluded keywords.
- 🗓️ Choose trend windows and end dates.
- ⚙️ Export clean JSON, CSV, Excel, or API results from Apify.

### Data you can extract

| Field | Description |
| --- | --- |
| `term` | Pinterest trend keyword |
| `country` | Market code |
| `trendType` | Top monthly, top yearly, growing, or seasonal |
| `rank` | Row rank in the extracted result set |
| `normalizedCount` | Pinterest normalized count when available |
| `searchCount` | Search count score when available |
| `weeklyChange` | Week-over-week change |
| `monthlyChange` | Month-over-month change |
| `yearlyChange` | Year-over-year change |
| `seasonalityScore` | Seasonal relevance score |
| `pinterestTrendsUrl` | Deep link to Pinterest Trends |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape Pinterest Trends?

The actor uses pay-per-event pricing.

You pay a small start charge for each run and a per-result charge for each trend keyword saved.

A small default run with one country and 25 results is designed to stay inexpensive.

### How to use Pinterest Trends Scraper

1. Open the actor on Apify.
2. Choose one or more country codes.
3. Select trend types.
4. Set the maximum results per country and type.
5. Optionally add keyword filters.
6. Run the actor.
7. Download the dataset or consume it through the API.

### Input options

#### Countries

Use Pinterest Trends country or region codes.

Common examples:

- `US`
- `CA`
- `GB+IE`
- `DE`
- `FR`
- `IT`
- `ES`
- `MX`
- `BR`
- `AU+NZ`
- `JP`

#### Trend types

Choose one or more:

- `top_monthly`
- `top_yearly`
- `growing`
- `seasonal`

#### Keyword filters

Use `keywordsToInclude` to focus on a topic.

Use `keywordsToExclude` to remove irrelevant terms.

#### Lookback window

Supported windows:

- `7D`
- `30D`
- `90D`
- `180D`
- `365D`

### Example input

```json
{
  "countries": ["US", "CA"],
  "trendTypes": ["growing"],
  "maxResultsPerCountry": 25,
  "lookbackWindow": "30D",
  "keywordsToInclude": ["nails"]
}
````

### Example output

```json
{
  "term": "may nails",
  "country": "US",
  "trendType": "growing",
  "rank": 3,
  "normalizedCount": 41,
  "searchCount": 41,
  "weeklyChange": -0.3,
  "monthlyChange": 6,
  "yearlyChange": 1,
  "seasonalityScore": 0.8292736,
  "pinterestTrendsUrl": "https://trends.pinterest.com/detail/?terms=may+nails&country=US",
  "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

### Tips for better results

- Start with one country and one trend type.
- Increase `maxResultsPerCountry` after validating the output.
- Use keyword filters for niche research.
- Compare `growing` and `seasonal` trend types for campaign planning.
- Use regional codes such as `GB+IE` or `AU+NZ` when Pinterest groups markets.

### Integrations

#### Content calendar workflow

Run weekly and send results to Google Sheets, Airtable, or Notion.

#### Ecommerce workflow

Filter by product terms and send rising trends to a merchandising dashboard.

#### Agency reporting workflow

Run one market per client and export CSV reports.

#### SEO workflow

Use trend keywords as seed ideas for keyword research tools.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/pinterest-trends-scraper').call({
  countries: ['US'],
  trendTypes: ['growing'],
  maxResultsPerCountry: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/pinterest-trends-scraper').call(run_input={
    'countries': ['US'],
    'trendTypes': ['growing'],
    'maxResultsPerCountry': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~pinterest-trends-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"countries":["US"],"trendTypes":["growing"],"maxResultsPerCountry":25}'
```

### MCP access

Use the Apify MCP server with Claude Code or Claude Desktop.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/pinterest-trends-scraper
```

Claude Code setup:

```bash
claude mcp add apify-pinterest-trends "https://mcp.apify.com/?tools=automation-lab/pinterest-trends-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-pinterest-trends": {
      "url": "https://mcp.apify.com/?tools=automation-lab/pinterest-trends-scraper"
    }
  }
}
```

Example prompts:

- "Run Pinterest Trends Scraper for US growing trends and summarize ecommerce ideas."
- "Compare Pinterest seasonal trends in US and CA."
- "Find Pinterest trend terms related to nails."

### Supported countries

Pinterest controls market availability.

If a country returns no rows, try a common supported market such as `US`, `CA`, `GB+IE`, `DE`, `FR`, `IT`, `ES`, `MX`, `BR`, `AU+NZ`, or `JP`.

### Limitations

Pinterest may change its public Trends endpoints.

Some countries, filters, or trend types can return fewer rows than requested.

The actor does not scrape individual pins, boards, or profiles.

### Troubleshooting

#### Why did I get zero results?

Try `US` with `growing`, remove keyword filters, and use a recent end date.

#### Why are some growth values null?

Pinterest does not return every metric for every trend row.

#### Can I scrape pins too?

This actor focuses on Trends. Use a Pinterest pin/profile scraper for pin-level data.

### Legality

This actor collects publicly available trend data.

Make sure your use of the data complies with Pinterest terms, privacy laws, and your internal policies.

Do not use scraped data for spam, harassment, or unlawful profiling.

### Related scrapers

- https://apify.com/automation-lab/pinterest-scraper
- https://apify.com/automation-lab/tiktok-hashtag-scraper
- https://apify.com/automation-lab/google-trends-scraper
- https://apify.com/automation-lab/instagram-hashtag-scraper

### Changelog

#### 0.1

Initial version with Pinterest Trends keyword extraction.

### Support

If you need a new field or market, open an issue on the actor page.

### Output quality checklist

- One row per trend keyword.
- Numeric growth metrics where Pinterest provides them.
- Market and trend type on every row.
- Deep link back to Pinterest Trends.

### Performance notes

The actor uses direct HTTP requests rather than a browser.

This keeps runs fast and cost-efficient.

### Versioning

The actor follows semantic-ish Apify build versions.

Breaking output changes will be documented in this README.

### FAQ

#### Does this require a Pinterest account?

No account is required for the current public Trends endpoints used by this actor.

#### Can I run multiple countries?

Yes. The actor loops over every selected country and trend type.

#### Can I schedule it?

Yes. Use Apify schedules to run daily, weekly, or monthly.

# Actor input Schema

## `countries` (type: `array`):

Pinterest Trends market codes. Common values: US, CA, GB+IE, DE, FR, IT, ES, MX, BR, AU+NZ, JP.

## `trendTypes` (type: `array`):

Types of Pinterest Trends tables to extract.

## `maxResultsPerCountry` (type: `integer`):

Number of trend keywords to return for each country and trend type.

## `endDate` (type: `string`):

End date in YYYY-MM-DD format. Defaults to today.

## `lookbackWindow` (type: `string`):

Time window used for trend calculations.

## `keywordsToInclude` (type: `array`):

Optional keyword filters. Example: nails, wedding, graduation.

## `keywordsToExclude` (type: `array`):

Optional keywords to filter out.

## `interestIds` (type: `array`):

Optional Pinterest interest/category IDs for category-specific trend extraction.

## `rankingMethod` (type: `string`):

Optional ranking metric for filtered trend lists.

## Actor input object example

```json
{
  "countries": [
    "US"
  ],
  "trendTypes": [
    "growing"
  ],
  "maxResultsPerCountry": 20,
  "endDate": "2026-05-22",
  "lookbackWindow": "30D",
  "keywordsToInclude": [],
  "keywordsToExclude": [],
  "interestIds": []
}
```

# 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 = {
    "countries": [
        "US"
    ],
    "trendTypes": [
        "growing"
    ],
    "maxResultsPerCountry": 20,
    "endDate": "2026-05-22",
    "lookbackWindow": "30D",
    "keywordsToInclude": [],
    "keywordsToExclude": [],
    "interestIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pinterest-trends-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 = {
    "countries": ["US"],
    "trendTypes": ["growing"],
    "maxResultsPerCountry": 20,
    "endDate": "2026-05-22",
    "lookbackWindow": "30D",
    "keywordsToInclude": [],
    "keywordsToExclude": [],
    "interestIds": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pinterest-trends-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 '{
  "countries": [
    "US"
  ],
  "trendTypes": [
    "growing"
  ],
  "maxResultsPerCountry": 20,
  "endDate": "2026-05-22",
  "lookbackWindow": "30D",
  "keywordsToInclude": [],
  "keywordsToExclude": [],
  "interestIds": []
}' |
apify call automation-lab/pinterest-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Trends Scraper",
        "description": "Extract Pinterest trend keywords, growth signals, seasonal scores, and market metadata for content, ecommerce, and ad research.",
        "version": "0.1",
        "x-build-id": "hze7JPH3vm1JHdXeU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~pinterest-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-pinterest-trends-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/automation-lab~pinterest-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-pinterest-trends-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/automation-lab~pinterest-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-pinterest-trends-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "countries"
                ],
                "properties": {
                    "countries": {
                        "title": "Countries / regions",
                        "type": "array",
                        "description": "Pinterest Trends market codes. Common values: US, CA, GB+IE, DE, FR, IT, ES, MX, BR, AU+NZ, JP.",
                        "default": [
                            "US"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "trendTypes": {
                        "title": "Trend types",
                        "type": "array",
                        "description": "Types of Pinterest Trends tables to extract.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "top_monthly",
                                "top_yearly",
                                "growing",
                                "seasonal"
                            ],
                            "enumTitles": [
                                "Top monthly trends",
                                "Top yearly trends",
                                "Growing trends",
                                "Seasonal trends"
                            ]
                        },
                        "default": [
                            "growing"
                        ]
                    },
                    "maxResultsPerCountry": {
                        "title": "Max trends per country/type",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Number of trend keywords to return for each country and trend type.",
                        "default": 20
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "End date in YYYY-MM-DD format. Defaults to today."
                    },
                    "lookbackWindow": {
                        "title": "Lookback window",
                        "enum": [
                            "7D",
                            "30D",
                            "90D",
                            "180D",
                            "365D"
                        ],
                        "type": "string",
                        "description": "Time window used for trend calculations.",
                        "default": "30D"
                    },
                    "keywordsToInclude": {
                        "title": "Keywords to include",
                        "type": "array",
                        "description": "Optional keyword filters. Example: nails, wedding, graduation.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywordsToExclude": {
                        "title": "Keywords to exclude",
                        "type": "array",
                        "description": "Optional keywords to filter out.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "interestIds": {
                        "title": "Pinterest interest IDs",
                        "type": "array",
                        "description": "Optional Pinterest interest/category IDs for category-specific trend extraction.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "rankingMethod": {
                        "title": "Ranking method",
                        "enum": [
                            "TREND_RANK",
                            "TOTAL_SEARCH",
                            "WEEKLY_CHANGE",
                            "MONTHLY_CHANGE",
                            "YEARLY_CHANGE"
                        ],
                        "type": "string",
                        "description": "Optional ranking metric for filtered trend lists."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
