# Pinterest API Scraper (`imbuedata/pinterest-api-scraper`) Actor

Scrape Pinterest pins, boards, users, search results, and private feeds via Pinterest's internal API. Supports 20+ actions including pin details, board scraping, user profiles, search, and more.

- **URL**: https://apify.com/imbuedata/pinterest-api-scraper.md
- **Developed by:** [ImbueData](https://apify.com/imbuedata) (community)
- **Categories:** Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 API Scraper

Extract data from Pinterest without needing an official API key. Scrape pins, boards, user profiles, search results, followers, and more — with full pagination support and optional cookie-based access to private content.

### What does this actor do?

This actor wraps Pinterest's internal API and exposes it as a clean, structured scraper. Choose an **action**, provide the required inputs, and get back JSON data pushed directly to your Apify Dataset.

Supports **20+ actions** across pins, boards, users, and private feeds.

---

### 🔍 Use Cases

- **Content research** — Search pins by keyword and collect media, descriptions, and engagement stats
- **Competitor analysis** — Scrape a brand's boards, pins, and follower count
- **Influencer discovery** — Get user profiles, activity pins, and following/followers data
- **Dataset building** — Bulk-collect pin images, titles, and categories for ML training
- **Social monitoring** — Track board updates, new pins, and recommendations

---

### ⚡ Actions

#### Pins

| Action | Description | Required Input |
|---|---|---|
| `getPinInfo` | Raw pin data from Pinterest API | `pinUrl` or `pinId` |
| `getPinDetails` | Formatted pin with typed media (image/video/story/GIF/carousel) | `pinUrl` or `pinId` |
| `getRelatedPins` | Pins related/recommended for a given pin | `pinUrl` or `pinId` |
| `searchPins` | Search Pinterest by keyword | `query` |

#### Boards

| Action | Description | Required Input |
|---|---|---|
| `getBoardDetails` | Board metadata (name, description, pin count, owner) | `boardUrl` or `username` + `boardSlug` |
| `getBoardPins` | All pins inside a board | `boardId` |
| `getBoardSections` | List of sections inside a board | `boardId` |
| `getBoardSectionById` | Single section details by ID | `sectionId` |
| `getBoardSectionBySlug` | Single section details by slug | `username`, `boardSlug`, `sectionSlug` |
| `getSectionPins` | All pins inside a board section | `sectionId` |
| `getBoardRecommendations` | Content recommendations for a board | `boardId` |
| `getBoardFeed` | Board feed pins | `boardId` |
| `getBoardSectionsRepin` | Board sections with repin data | `boardId` |

#### Users

| Action | Description | Required Input |
|---|---|---|
| `getUserProfile` | Profile info: bio, follower count, website, etc. | `username` |
| `getUserPins` | All pins saved by a user | `username` |
| `getUserBoards` | All public boards of a user | `username` |
| `getUserActivityPins` | Recent activity pins | `username` |
| `getUserFollowing` | Accounts a user follows *(requires cookie)* | `username`, `cookie` |
| `getUserFollowers` | A user's followers via GraphQL | `userId` |

#### Private *(requires session cookie)*

| Action | Description | Required Input |
|---|---|---|
| `getHomeFeed` | Your personal Pinterest home feed | `cookie` |
| `getBestPinsFeed` | Top pins for a given interest/category | `interest` |
| `getInterest` | Metadata for a Pinterest interest | `interest` |
| `getUserPrivateBoards` | All boards including private ones | `username`, `cookie` |
| `getBoardPickerBoards` | Board list as shown in Pinterest's save dialog | `cookie` |

---

### 📥 Input Examples

**Search pins:**
```json
{
  "action": "searchPins",
  "query": "minimalist home decor",
  "maxItems": 50
}
````

**Get all pins from a board:**

```json
{
  "action": "getBoardPins",
  "boardId": "1234567890",
  "maxItems": 200
}
```

**Get a user's profile:**

```json
{
  "action": "getUserProfile",
  "username": "nasa"
}
```

**Scrape board details from URL:**

```json
{
  "action": "getBoardDetails",
  "boardUrl": "https://www.pinterest.com/nasa/hubble-space-telescope/"
}
```

***

### 📤 Output

All results are pushed to the **Apify Dataset** as JSON records. Example pin output:

```json
{
  "id": "1234567890",
  "title": "Minimalist Living Room",
  "description": "Clean lines and neutral tones...",
  "category": "home_decor",
  "media": {
    "media_type": "image",
    "items": { "orig": { "url": "https://i.pinimg.com/originals/..." } }
  },
  "repin_count": 342,
  "comment_count": 12,
  "created_at": "2024-03-15T10:22:00",
  "board_owner": { "username": "designstudio" }
}
```

***

### 🔄 Pagination

Set **`maxItems`** to automatically paginate across multiple pages.

- `maxItems: 0` — single page only (default)
- `maxItems: 100` — collect up to 100 items, paginating as needed
- Use **`bookmark`** to resume from a previous run's cursor

***

### 🔐 Getting Your Pinterest Cookie

Required for: `getUserFollowing`, `getHomeFeed`, `getUserPrivateBoards`, `getBoardPickerBoards`

1. Open [pinterest.com](https://www.pinterest.com) in your browser and log in
2. Press **F12** → go to the **Network** tab → reload the page
3. Click any request to `pinterest.com` → open **Headers**
4. Find the **`Cookie`** request header → copy its full value
5. Paste it into the `cookie` field in the input (it will be stored securely as a secret)

> ⚠️ Never share your cookie. It grants access to your Pinterest account.

***

### ❓ FAQ

**Does this require a Pinterest API key or developer account?**
No. This actor uses Pinterest's internal (unofficial) API. No API key, OAuth, or developer approval needed for public data.

**Does it work without logging in?**
Yes — all public actions (pins, boards, user profiles, search) work with no credentials. Only private actions (home feed, private boards, following) require your session cookie.

**How does this compare to Pinterest's official API?**
Pinterest's official API requires an approved developer account, has strict rate limits, and limits available data fields. This actor bypasses all of that — no approval, no rate cap, and returns more fields including dominant color, full-resolution images, board sections, and private content.

**Can I scrape Pinterest private boards?**
Yes — use the `getUserPrivateBoards` action with your session cookie to access boards including private ones.

**Can I scrape Pinterest home feed?**
Yes — use the `getHomeFeed` action with your session cookie.

**Can I get Pinterest followers without an API key?**
Yes — use the `getUserFollowers` action with just a `userId`. No credentials needed.

**Can I scrape Pinterest board sections?**
Yes — `getBoardSections`, `getBoardSectionById`, `getBoardSectionBySlug`, and `getSectionPins` are all supported.

**How do I paginate results?**
Set `maxItems` to automatically collect across pages. Use the `bookmark` field to resume a previous run from where it left off.

**Is it legal to scrape Pinterest?**
Scraping publicly available data is generally legal, consistent with the 2022 US court ruling in hiQ Labs v. LinkedIn. This actor only accesses public data by default. Always comply with Pinterest's [Terms of Service](https://policy.pinterest.com/en/terms-of-service) and applicable data protection laws.

***

### ⚠️ Disclaimer

This actor uses Pinterest's internal (unofficial) API. It is intended for personal use, research, and data analysis. Always respect Pinterest's [Terms of Service](https://policy.pinterest.com/en/terms-of-service) and use responsibly.

# Actor input Schema

## `action` (type: `string`):

The Pinterest API action to perform.

## `pinUrl` (type: `string`):

Full or short Pinterest pin URL (e.g. https://www.pinterest.com/pin/123456789/ or https://pin.it/abc). Used by: getPinInfo, getPinDetails, getRelatedPins.

## `pinId` (type: `string`):

Pinterest pin ID (numeric). Alternative to pinUrl.

## `boardUrl` (type: `string`):

Full Pinterest board URL (e.g. https://www.pinterest.com/username/board-name/). Used by: getBoardDetails.

## `boardId` (type: `string`):

Pinterest board ID (numeric). Used by: getBoardPins, getBoardSections, getBoardSectionById, getBoardRecommendations, getBoardFeed, getBoardSectionsRepin.

## `sectionId` (type: `string`):

Pinterest board section ID. Used by: getBoardSectionById, getSectionPins.

## `username` (type: `string`):

Pinterest username (without @). Used by: getUserBoards, getUserPins, getUserProfile, getUserActivityPins, getUserFollowing, getBoardSectionBySlug, getUserPrivateBoards.

## `boardSlug` (type: `string`):

Board URL slug (the part after username in the URL). Used by: getBoardSectionBySlug.

## `sectionSlug` (type: `string`):

Section URL slug. Used by: getBoardSectionBySlug.

## `userId` (type: `string`):

Pinterest user ID (numeric). Used by: getUserFollowers.

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

Search term. Used by: searchPins.

## `interest` (type: `string`):

Pinterest interest/category slug. Used by: getBestPinsFeed, getInterest.

## `cookie` (type: `string`):

Your Pinterest session cookie string. Required for private actions: getUserFollowing, getHomeFeed, getUserPrivateBoards, getBoardPickerBoards.

## `bookmark` (type: `string`):

Pagination cursor from a previous run. Leave empty to start from the beginning.

## `maxItems` (type: `integer`):

Maximum number of items to collect. When set and the action supports pagination, the actor will auto-paginate until this limit is reached. Set to 0 for a single page only.

## Actor input object example

```json
{
  "maxItems": 0
}
```

# Actor output Schema

## `id` (type: `string`):

Unique Pinterest item ID

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

Item type: Image, Video, Story, GIF, Carousel, Board, User

## `title` (type: `string`):

Pin or board title

## `description` (type: `string`):

Pin or board description

## `url` (type: `string`):

Link to the Pinterest item

## `imageUrl` (type: `string`):

Full-resolution image URL

## `videoUrl` (type: `string`):

Video URL for video pins

## `repin_count` (type: `string`):

Number of repins/saves

## `comment_count` (type: `string`):

Number of comments

## `created_at` (type: `string`):

Creation timestamp

## `username` (type: `string`):

Pinterest username

## `full_name` (type: `string`):

User's full display name

## `follower_count` (type: `string`):

Number of followers

## `following_count` (type: `string`):

Number of accounts followed

## `board_count` (type: `string`):

Number of boards

## `pin_count` (type: `string`):

Number of pins in a board

## `name` (type: `string`):

Board or section name

## `category` (type: `string`):

Pinterest category

## `website` (type: `string`):

User's website URL

# 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("imbuedata/pinterest-api-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 = {}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest API Scraper",
        "description": "Scrape Pinterest pins, boards, users, search results, and private feeds via Pinterest's internal API. Supports 20+ actions including pin details, board scraping, user profiles, search, and more.",
        "version": "1.0",
        "x-build-id": "oxymrdVZHuYQHlax5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/imbuedata~pinterest-api-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-imbuedata-pinterest-api-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/imbuedata~pinterest-api-scraper/runs": {
            "post": {
                "operationId": "runs-sync-imbuedata-pinterest-api-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/imbuedata~pinterest-api-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-imbuedata-pinterest-api-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": [
                    "action"
                ],
                "properties": {
                    "action": {
                        "title": "Action",
                        "enum": [
                            "getPinInfo",
                            "getPinDetails",
                            "getRelatedPins",
                            "searchPins",
                            "getBoardDetails",
                            "getBoardPins",
                            "getBoardSections",
                            "getBoardSectionById",
                            "getBoardSectionBySlug",
                            "getSectionPins",
                            "getBoardRecommendations",
                            "getBoardFeed",
                            "getBoardSectionsRepin",
                            "getUserBoards",
                            "getUserPins",
                            "getUserProfile",
                            "getUserActivityPins",
                            "getUserFollowing",
                            "getUserFollowers",
                            "getHomeFeed",
                            "getBestPinsFeed",
                            "getInterest",
                            "getUserPrivateBoards",
                            "getBoardPickerBoards"
                        ],
                        "type": "string",
                        "description": "The Pinterest API action to perform."
                    },
                    "pinUrl": {
                        "title": "Pin URL",
                        "type": "string",
                        "description": "Full or short Pinterest pin URL (e.g. https://www.pinterest.com/pin/123456789/ or https://pin.it/abc). Used by: getPinInfo, getPinDetails, getRelatedPins."
                    },
                    "pinId": {
                        "title": "Pin ID",
                        "type": "string",
                        "description": "Pinterest pin ID (numeric). Alternative to pinUrl."
                    },
                    "boardUrl": {
                        "title": "Board URL",
                        "type": "string",
                        "description": "Full Pinterest board URL (e.g. https://www.pinterest.com/username/board-name/). Used by: getBoardDetails."
                    },
                    "boardId": {
                        "title": "Board ID",
                        "type": "string",
                        "description": "Pinterest board ID (numeric). Used by: getBoardPins, getBoardSections, getBoardSectionById, getBoardRecommendations, getBoardFeed, getBoardSectionsRepin."
                    },
                    "sectionId": {
                        "title": "Section ID",
                        "type": "string",
                        "description": "Pinterest board section ID. Used by: getBoardSectionById, getSectionPins."
                    },
                    "username": {
                        "title": "Username",
                        "type": "string",
                        "description": "Pinterest username (without @). Used by: getUserBoards, getUserPins, getUserProfile, getUserActivityPins, getUserFollowing, getBoardSectionBySlug, getUserPrivateBoards."
                    },
                    "boardSlug": {
                        "title": "Board Slug",
                        "type": "string",
                        "description": "Board URL slug (the part after username in the URL). Used by: getBoardSectionBySlug."
                    },
                    "sectionSlug": {
                        "title": "Section Slug",
                        "type": "string",
                        "description": "Section URL slug. Used by: getBoardSectionBySlug."
                    },
                    "userId": {
                        "title": "User ID",
                        "type": "string",
                        "description": "Pinterest user ID (numeric). Used by: getUserFollowers."
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term. Used by: searchPins."
                    },
                    "interest": {
                        "title": "Interest",
                        "type": "string",
                        "description": "Pinterest interest/category slug. Used by: getBestPinsFeed, getInterest."
                    },
                    "cookie": {
                        "title": "Pinterest Cookie",
                        "type": "string",
                        "description": "Your Pinterest session cookie string. Required for private actions: getUserFollowing, getHomeFeed, getUserPrivateBoards, getBoardPickerBoards."
                    },
                    "bookmark": {
                        "title": "Bookmark (Pagination Cursor)",
                        "type": "string",
                        "description": "Pagination cursor from a previous run. Leave empty to start from the beginning."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of items to collect. When set and the action supports pagination, the actor will auto-paginate until this limit is reached. Set to 0 for a single page only.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```