# Pinterest Search Scraper (`fetch_cat/pinterest-search-scraper`) Actor

Scrape public Pinterest search results by keyword. Export pin URLs, titles, images, thumbnails, positions, colors, creator/board fields, and outbound domains when visible.

- **URL**: https://apify.com/fetch\_cat/pinterest-search-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, E-commerce
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 result extracteds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Pinterest Search Scraper

Scrape public Pinterest search results by keyword and export clean pin metadata for trend research, creative analysis, ecommerce inspiration, and content planning.

### What does Pinterest Search Scraper do?

Pinterest Search Scraper searches Pinterest for one or more keywords and saves public pin records to an Apify dataset.

Use it to collect ranking snapshots, image URLs, pin URLs, titles, and other public metadata that Pinterest exposes without logging in.

The actor is designed for simple keyword monitoring and repeatable exports.

### Who is it for?

#### Marketing teams

Track which pin creatives appear for campaign keywords.

#### Ecommerce researchers

Collect product inspiration and image examples around seasonal trends.

#### SEO and content teams

Research Pinterest result language, themes, and visual patterns.

#### Trend analysts

Monitor ranking changes for home decor, fashion, beauty, recipes, and other visual categories.

#### Agencies

Create repeatable Pinterest discovery exports for clients.

### Why use this actor?

- 🔎 Search multiple Pinterest keywords in one run.
- 🧾 Export structured dataset rows instead of screenshots.
- 🖼️ Capture image and thumbnail URLs for creative review.
- 📌 Store stable pin IDs and pin URLs.
- 📊 Keep ranking position per keyword.
- ⚙️ Use optional proxies and locale settings.
- 🔁 Schedule recurring runs on Apify.

### Pinterest keyword research workflows

Use Pinterest Search Scraper to create public keyword snapshots for:

- Creative mood boards and visual inspiration research.
- Ecommerce product and merchandising ideas.
- Seasonal trend tracking across repeated searches.
- SEO, content brief, and social-planning inputs.

### What data can you extract from Pinterest search?

| Field | Description |
| --- | --- |
| `query` | Keyword used for the Pinterest search. |
| `position` | Result position within the keyword. |
| `pinId` | Pinterest pin identifier. |
| `pinUrl` | Public Pinterest pin URL. |
| `title` | Public title or image alt text. |
| `description` | Public description when available. |
| `imageUrl` | Larger image URL when available. |
| `thumbnailUrl` | Thumbnail image URL. |
| `dominantColor` | Background color exposed in the public card. |
| `creatorName` | Creator name when public and available. |
| `creatorUsername` | Creator username when public and available. |
| `creatorUrl` | Creator URL when public and available. |
| `boardName` | Board name when public and available. |
| `boardUrl` | Board URL when public and available. |
| `domain` | Linked domain when public and available. |
| `outboundUrl` | External URL when public and available. |
| `repinCount` | Repin count when public and available. |
| `saveCount` | Save count when public and available. |
| `fetchedAt` | Timestamp of the scrape. |

### How much does it cost to scrape Pinterest search results?

This actor uses pay-per-event pricing.

You pay a $0.005 run-start fee and then a formula-derived per-result fee for each Pinterest pin saved to the dataset. The BRONZE per-pin price is $0.00016162, with standard tier discounts for larger paid usage.

The input prefill is intentionally small so your first run is inexpensive.

For large monitoring jobs, use a reasonable `maxResultsPerQuery` and schedule recurring runs only as often as your workflow needs.

### How to scrape Pinterest search results

1. Open the actor on Apify.
2. Add one or more Pinterest search keywords.
3. Set the maximum number of pins per keyword.
4. Keep the default proxy setting for a small test.
5. Start the run.
6. Download results from the dataset as JSON, CSV, Excel, XML, or HTML.

### Input configuration

#### `queries`

Pinterest keywords to search.

Example:

```json
["home decor", "summer outfits", "apify"]
````

#### `maxResultsPerQuery`

Maximum number of pins to save for each keyword.

Use a low value for testing and a higher value for production exports.

#### `includePinDetails`

When enabled, the actor tries to open each pin page and enrich metadata that Pinterest exposes publicly.

Pinterest can show a login wall on pin pages, so the search-card fields are the reliable default.

#### `locale`

Browser locale and `Accept-Language` header.

#### `country`

Optional country label for your own run context.

To route traffic by country, set the proxy country inside the proxy configuration.

#### `proxyConfiguration`

Optional Apify proxy settings.

Start without proxies for small tests.

If Pinterest blocks your workload, enable Apify Proxy and choose the proxy group that works for your use case.

### Example input

```json
{
  "queries": ["home decor", "summer outfits", "apify"],
  "maxResultsPerQuery": 25,
  "includePinDetails": false,
  "locale": "en-US",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### Example output

```json
{
  "query": "home decor",
  "position": 1,
  "pinId": "123456789012345678",
  "pinUrl": "https://www.pinterest.com/pin/123456789012345678/",
  "title": "Cozy living room decor ideas",
  "description": null,
  "imageUrl": "https://i.pinimg.com/736x/example.jpg",
  "thumbnailUrl": "https://i.pinimg.com/236x/example.jpg",
  "dominantColor": "rgb(195, 184, 170)",
  "creatorName": null,
  "creatorUsername": null,
  "creatorUrl": null,
  "boardName": null,
  "boardUrl": null,
  "domain": null,
  "outboundUrl": null,
  "repinCount": null,
  "saveCount": null,
  "fetchedAt": "2026-06-22T00:00:00.000Z"
}
```

### Tips for better Pinterest scraping

- 🧪 Test with 10-25 results before running larger jobs.
- 🔁 Schedule the same keywords daily or weekly to compare rankings.
- 🗂️ Export CSV for spreadsheet workflows.
- 🖼️ Use `imageUrl` and `thumbnailUrl` for creative mood boards.
- 🌍 Adjust locale and proxy settings when you need regional testing.

### Integrations

#### Google Sheets

Send dataset rows to Google Sheets for weekly creative review.

#### Airtable

Store pin ideas and classify them by keyword, product line, or campaign.

#### Slack

Notify your team when a scheduled run finishes.

#### BI dashboards

Load dataset exports into dashboards to track keyword coverage over time.

#### Content workflows

Use results as raw research for briefs, mood boards, and editorial planning.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/pinterest-search-scraper').call({
  queries: ['home decor'],
  maxResultsPerQuery: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/pinterest-search-scraper').call(run_input={
    'queries': ['home decor'],
    'maxResultsPerQuery': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~pinterest-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["home decor"],"maxResultsPerQuery":25}'
```

### MCP usage

Use the Apify MCP server to run this actor from compatible AI tools.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/pinterest-search-scraper
```

Add the MCP server in Claude Code:

```bash
claude mcp add apify-pinterest-search https://mcp.apify.com/?tools=fetch_cat/pinterest-search-scraper
```

Claude Desktop JSON configuration:

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

Example prompts showing MCP usage:

#### Claude Desktop prompt

"Run Pinterest Search Scraper for `home decor` and summarize the most common visual themes."

#### Claude Code prompt

"Use Apify MCP to scrape Pinterest search results for `summer outfits`, then save the dataset as CSV."

#### Automation prompt

"Schedule a weekly Pinterest search scrape for my product keywords and alert me when the dataset is ready."

### Legality

This actor extracts public Pinterest search information that is visible without an account.

You are responsible for using the data lawfully and respecting Pinterest's terms, privacy rights, and applicable regulations.

Do not use the actor to collect private account data, bypass login walls, or scrape personal information beyond what is publicly available.

### FAQ

#### Why did I get fewer pins than requested?

Pinterest may show fewer public results for a keyword, slow down loading, or display duplicate cards. Try a broader keyword or a lower per-keyword limit.

#### Why are creator, board, or outbound fields sometimes null?

Pinterest does not always expose creator, board, outbound, or engagement fields in public logged-out search cards. The actor keeps those fields in the schema for stable exports when public data is available.

#### Should I enable proxies?

For small tests, try the default setting first. If Pinterest blocks or throttles your workload, enable Apify Proxy and test again with a small result limit.

#### Can I scrape private boards or account-only data?

No. This actor is for public search results only.

### Related actors

Explore other Apify actors by fetch\_cat for search, social media, ecommerce, and content research workflows.

- https://apify.com/fetch\_cat/google-trending-searches-scraper
- https://apify.com/fetch\_cat/google-autocomplete-scraper
- https://apify.com/fetch\_cat/google-news-scraper
- https://apify.com/fetch\_cat/shopify-products-scraper

### Limits

Pinterest can change its public page structure at any time.

Large runs may need proxies and lower concurrency.

Pin detail enrichment is best effort because Pinterest often shows login prompts on detail pages.

### Changelog

#### 0.1

Initial version with keyword search, rendered public pin extraction, dataset schema, optional proxy configuration, and optional detail enrichment.

### Support

If a run fails, include the run URL, input, and a short description of what you expected.

Small reproducible examples are easiest to diagnose.

### Summary

Pinterest Search Scraper turns public Pinterest keyword searches into clean datasets.

Use it to monitor visual trends, collect pin URLs and images, and power repeatable research workflows on Apify.

# Actor input Schema

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

Keywords to search on Pinterest. Each keyword is scraped separately and returned with its own positions.

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

How many public pins to save for each search keyword.

## `includePinDetails` (type: `boolean`):

Open each pin page and collect public metadata when Pinterest exposes it anonymously. This is slower and may return the same fields if Pinterest shows a login wall.

## `locale` (type: `string`):

Browser locale and Accept-Language header used for the Pinterest session.

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

Optional country label for your run. To route traffic through a country, also set the proxy country in proxy configuration.

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

Optional proxy settings. Datacenter proxies are usually tried first; switch to residential if Pinterest blocks your workload.

## Actor input object example

```json
{
  "queries": [
    "home decor",
    "summer outfits",
    "apify"
  ],
  "maxResultsPerQuery": 10,
  "includePinDetails": false,
  "locale": "en-US",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "home decor",
        "summer outfits",
        "apify"
    ],
    "maxResultsPerQuery": 10,
    "locale": "en-US",
    "country": "US",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/pinterest-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": [
        "home decor",
        "summer outfits",
        "apify",
    ],
    "maxResultsPerQuery": 10,
    "locale": "en-US",
    "country": "US",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/pinterest-search-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "home decor",
    "summer outfits",
    "apify"
  ],
  "maxResultsPerQuery": 10,
  "locale": "en-US",
  "country": "US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/pinterest-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Search Scraper",
        "description": "Scrape public Pinterest search results by keyword. Export pin URLs, titles, images, thumbnails, positions, colors, creator/board fields, and outbound domains when visible.",
        "version": "0.1",
        "x-build-id": "FdWf3zsGldy5QpjMc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~pinterest-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-pinterest-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~pinterest-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-pinterest-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~pinterest-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-pinterest-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Pinterest search keywords",
                        "type": "array",
                        "description": "Keywords to search on Pinterest. Each keyword is scraped separately and returned with its own positions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum pins per keyword",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many public pins to save for each search keyword.",
                        "default": 20
                    },
                    "includePinDetails": {
                        "title": "Try to enrich pin details",
                        "type": "boolean",
                        "description": "Open each pin page and collect public metadata when Pinterest exposes it anonymously. This is slower and may return the same fields if Pinterest shows a login wall.",
                        "default": false
                    },
                    "locale": {
                        "title": "Locale",
                        "type": "string",
                        "description": "Browser locale and Accept-Language header used for the Pinterest session.",
                        "default": "en-US"
                    },
                    "country": {
                        "title": "Country note",
                        "type": "string",
                        "description": "Optional country label for your run. To route traffic through a country, also set the proxy country in proxy configuration.",
                        "default": "US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Datacenter proxies are usually tried first; switch to residential if Pinterest blocks your workload.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
