# Pinterest Keyword Suggestions Scraper (`benthepythondev/pinterest-keyword-suggestions-scraper`) Actor

Collect Pinterest autocomplete keywords and optional creator suggestions from seed terms, with alphabet expansion, ranks, URLs and profile metadata.

- **URL**: https://apify.com/benthepythondev/pinterest-keyword-suggestions-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** SEO tools, Marketing, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 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 Keyword Suggestions Scraper

Turn seed phrases into **public Pinterest autocomplete suggestions** for content planning, visual-search research, SEO ideation, campaign briefs, and creator discovery. Enter one or more keywords such as `home decor`, `wedding ideas`, or `healthy recipes`. The Actor returns Pinterest's current suggested searches with rank, suggestion ID, search URL, originating seed, and the exact expanded query that produced each result.

An optional alphabet mode appends letters to each seed to uncover additional long-tail phrases. You can also include public creator suggestions that Pinterest displays beside keyword results. Every record is saved to the default Apify dataset and can be exported as JSON, CSV, Excel, XML, or RSS, scheduled, called through the API, or connected to Make, Zapier, n8n, Sheets, a database, or a content workflow.

### What does the Actor collect?

Keyword rows can include:

- Original seed keyword
- Exact autocomplete request query
- Suggested Pinterest search phrase
- Pinterest suggestion ID
- Suggestion type
- Result and query rank
- Pinterest search URL
- Source result index
- Scrape timestamp

When `includeCreators` is enabled, creator suggestions can also include:

- Pinterest username
- Public display name
- Verification indicator
- Profile image URL
- Public native pin count when supplied
- Direct profile URL

Pinterest controls which types and fields appear for a given phrase. The Actor returns the public response and leaves unavailable fields empty rather than inventing data.

### Why use Pinterest suggestions?

Pinterest is a visual discovery platform. Its search suggestions reflect how the product currently organizes and expands a phrase, which can be useful for understanding vocabulary around styles, projects, occasions, products, and inspiration topics.

Common workflows include:

- Pinterest board and pin planning
- Long-tail keyword discovery
- Visual trend and topic research
- Content brief generation
- Product-category and use-case ideation
- Comparing suggestion sets over time
- Building a reviewed keyword backlog
- Finding public creator profiles associated with a topic
- Expanding a narrow seed before running a pin search
- Grouping related phrases for campaigns or editorial calendars

Suggestions are ideas and source observations, not search-volume measurements. A phrase appearing in autocomplete does not prove a specific number of searches, conversions, or purchases.

### Input

#### Seed-only mode

The default mode requests suggestions once per seed:

```json
{
  "seedKeywords": ["home decor", "wedding ideas"],
  "expansionMode": "seed_only",
  "includeCreators": false,
  "maxQueries": 10,
  "maxSuggestionsPerQuery": 12,
  "maxResults": 25
}
````

Use seed-only mode for a quick, controlled snapshot. Pinterest commonly returns a compact group of related phrases for each query, so the default finishes quickly.

#### Alphabet expansion

Alphabet expansion requests the seed and then variants such as `home decor a`, `home decor b`, and later letters until `maxQueries` or `maxResults` is reached:

```json
{
  "seedKeywords": ["home decor"],
  "expansionMode": "alphabet",
  "maxQueries": 10,
  "maxSuggestionsPerQuery": 12,
  "maxResults": 100
}
```

The Actor deduplicates suggestions across every expanded request. The first query and rank that produced a phrase are retained. Start with a small `maxQueries` value; more letters do not automatically produce more useful ideas.

#### Creator suggestions

Set `includeCreators` to `true` to retain public profile suggestions returned with the keywords:

```json
{
  "seedKeywords": ["home decor"],
  "includeCreators": true,
  "maxResults": 20
}
```

Keyword and creator records share the same dataset. Use `suggestion_type` to route or filter them downstream.

### Example keyword output

```json
{
  "seed_keyword": "home decor",
  "request_query": "home decor",
  "suggestion": "home decor ideas living room",
  "label": "home decor ideas living room",
  "suggestion_type": "query",
  "suggestion_id": "ac_Cz3LoPjZ",
  "url": "https://www.pinterest.com/search/pins/?q=home+decor+ideas+living+room&rs=ac",
  "query_rank": 1,
  "rank": 6,
  "source_result_index": 5,
  "scraped_at": "2026-07-11T09:00:00+00:00"
}
```

### Example creator output

```json
{
  "seed_keyword": "home decor",
  "request_query": "home decor",
  "suggestion": "Inspired by Charm | Easy Recipes and Home Decorating Ideas",
  "suggestion_type": "user",
  "username": "inspiredbycharm",
  "full_name": "Inspired by Charm | Easy Recipes and Home Decorating Ideas",
  "verified": true,
  "profile_image_url": "https://i.pinimg.com/75x75_RS/...jpg",
  "url": "https://www.pinterest.com/inspiredbycharm/",
  "rank": 11
}
```

These are representative live fields. Suggestions, ranks, profile matches, IDs, and URLs can change as Pinterest updates its search experience.

### A practical keyword workflow

1. Start with a small set of specific seed phrases.
2. Run seed-only mode and review the first suggestions.
3. Keep phrases aligned with the product, audience, or editorial question.
4. Use alphabet mode only for seeds that need more depth.
5. Deduplicate against the existing content backlog.
6. Group retained phrases by intent or theme.
7. Use Pinterest Search to inspect the actual pins ranking for selected phrases.
8. Save the date with every snapshot so later comparisons are meaningful.

The review step matters. Autocomplete can contain ambiguous, seasonal, redundant, or irrelevant phrases. Do not publish content automatically just because a phrase appeared.

For monitoring, store a durable key such as `seed_keyword + suggestion_type + suggestion`. On the next scheduled run, compare the new set with the previous set and alert only on additions, removals, or meaningful rank changes.

### Pricing

The Actor uses transparent pay-per-event pricing designed for small keyword rows:

- **$0.005** when the Actor starts
- **$0.0002** for each unique suggestion saved to the default dataset

A successful 25-result run costs about **$0.010** in Actor charges before ordinary Apify platform usage. A 100-result run costs about **$0.025**. `maxResults`, `maxQueries`, and `maxSuggestionsPerQuery` provide explicit spending controls.

The pricing is intentionally different from rich profile or listing scrapers. A compact autocomplete phrase should not cost the same as a fully enriched property, vehicle, or creator record.

### Reliability and implementation

The Actor uses Pinterest's public web autocomplete resource and the current public application version exposed by Pinterest's search page. It runs through direct Chrome-compatible HTTP without a browser, login, residential proxy, or paid unblocker.

Requests use bounded retries and explicit timeouts. Inputs, query expansion, and output are capped. Suggestions are deduplicated before they are pushed, and the Actor fails explicitly if Pinterest returns no useful records. That makes a source change visible in scheduled monitoring instead of silently returning an empty successful dataset.

The current Pinterest Search Actor uses the same proven public application bootstrap and has been tested independently in Apify Cloud. This keyword Actor uses a separate autocomplete resource and output schema, so it targets a distinct research task rather than duplicating pin-search results.

### Responsible use

Use the Actor for legitimate public search and content research. Follow Pinterest's terms, applicable law, intellectual-property rights, and your organization's compliance rules. Do not use creator suggestions for harassment, sensitive profiling, spam, or identity resolution.

A public creator result or website link is not automatic consent to contact. A suggestion is not a trademark clearance, content license, volume estimate, or guarantee of relevance. Review every phrase and source record before using it in a campaign or business decision.

### FAQ

#### Does the Actor require a Pinterest login?

No. It uses data available to public Pinterest search visitors.

#### What is the difference between seed-only and alphabet mode?

Seed-only requests each phrase once. Alphabet mode also appends letters to generate additional long-tail request queries, subject to `maxQueries` and `maxResults`.

#### Does the Actor return search volume?

No. Pinterest's public autocomplete response does not provide a verified search-volume metric. The Actor returns suggestions and their current response order.

#### Can it return creator accounts?

Yes. Enable `includeCreators`. Creator rows are included only when Pinterest returns them for the request.

#### Why did a phrase disappear or change rank?

Autocomplete is dynamic and can vary by time, market, product experiments, and source changes. Save `scraped_at` and treat each run as a point-in-time observation.

#### How do I report a problem?

Open an issue on the Actor page with the seed, run ID, expected field, and observed output. Do not post account credentials or private data.

If the Actor saves you time, please leave a Store review. Reviews help prioritize maintenance and help other users evaluate the tool.

### You might also like

- [Pinterest Search Scraper](https://apify.com/benthepythondev/pinterest-search-scraper) for pins, creators, boards, images, links, and result ranks
- [Pinterest Profile Scraper](https://apify.com/benthepythondev/pinterest-profile-scraper) for public profile enrichment
- [Google Keyword Suggestions Scraper](https://apify.com/benthepythondev/google-keyword-suggestions-scraper) for Google autocomplete research

### Keywords

Pinterest keyword scraper, Pinterest autocomplete API, Pinterest keyword suggestions, Pinterest SEO tool, Pinterest search terms, Pinterest keyword research, long-tail keyword generator, visual search research, Pinterest content ideas, Pinterest marketing data, autocomplete scraper, Pinterest creator discovery, Pinterest trends research, Apify Pinterest scraper

### Production workflow

This Actor is designed for SEO teams, content strategists, ecommerce marketers and creator researchers. Use a small set of commercial or editorial seed phrases, compare rank and query coverage, then retain suggestions that match the audience and funnel stage of the campaign. Small, repeatable runs are easier to audit than occasional unlimited exports: they expose source changes quickly, reduce duplicate processing and keep automation costs predictable. Use the input defaults as a smoke test, then widen the query only after confirming that the returned fields match the downstream workflow.

Treat each dataset row as source evidence captured at a point in time, not as a permanent fact. Preserve the canonical identifier and source URL, add the run timestamp in the receiving system, and deduplicate before writing to a CRM, spreadsheet, warehouse or alert channel. For recurring monitoring, compare the newest dataset with the previous successful run and send only additions or material changes onward. That pattern avoids repeated notifications and makes the automation more useful over time.

### Data quality and interpretation

The primary output includes `seed_keyword`, `request_query`, `suggestion`, `label`, `suggestion_type`, `suggestion_id`, `url`, `username`, `full_name`, `verified`, `profile_image_url`, `native_pin_count`. Availability depends on what the source publishes for a particular result. Empty values are retained as null or empty fields rather than invented. Search rank is source-specific and can change with language, geography, query wording and time. Validate critical decisions against the linked source page, especially when the data is used for outreach, compliance, pricing, routing or reporting.

Use bounded inputs and respect the source's published interface. The Actor does not bypass logins or collect private account data. Avoid placing passwords, session cookies, personal access tokens or confidential records in Actor input. If a public source changes its response shape, attach a reproducible public input and run ID to an Actor issue so the parser can be updated without exposing private data.

### Automation and cost control

The default dataset can be exported as JSON, CSV, Excel, XML or RSS and can be consumed through the Apify API. In Make, Zapier or n8n, start the Actor, wait for the run to finish, then read default-dataset items. In code, store the Actor run ID and dataset ID alongside the imported rows so every record remains traceable. Apply filters after collection only when the source cannot express them directly; source-side filtering usually reduces cost and noise.

This Actor uses pay-per-event billing. A result event is charged only when a structured row is saved to the default dataset. Keep test runs small, estimate expected row volume before scheduling broad searches, and use platform spending limits for unattended workflows. Failed requests and empty searches should not create result events.

### Support and feedback

If the Actor saves time in a real workflow, please leave a short Apify Store review describing the use case and the fields that were most useful. Reviews help other users evaluate the product and help prioritize maintenance. For support, open an Actor issue with the run ID, public input, expected behavior and one affected field. Do not include credentials or confidential information.

# Actor input Schema

## `seedKeywords` (type: `array`):

Pinterest search phrases used as autocomplete seeds.

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

Use each seed once, or append letters to discover additional long-tail suggestions.

## `includeCreators` (type: `boolean`):

Also save public creator/profile suggestions returned beside keyword suggestions.

## `maxQueries` (type: `integer`):

Safety limit for each seed in alphabet mode. Seed-only mode uses one query per seed.

## `maxSuggestionsPerQuery` (type: `integer`):

Maximum unique Pinterest suggestions saved from one autocomplete query.

## `maxResults` (type: `integer`):

Maximum unique keyword and creator suggestions saved across the full run.

## Actor input object example

```json
{
  "seedKeywords": [
    "home decor",
    "wedding ideas",
    "healthy recipes"
  ],
  "expansionMode": "seed_only",
  "includeCreators": false,
  "maxQueries": 10,
  "maxSuggestionsPerQuery": 12,
  "maxResults": 10
}
```

# Actor output Schema

## `results` (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 = {
    "seedKeywords": [
        "home decor",
        "wedding ideas",
        "healthy recipes"
    ],
    "expansionMode": "seed_only",
    "includeCreators": false,
    "maxQueries": 10,
    "maxSuggestionsPerQuery": 12,
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/pinterest-keyword-suggestions-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 = {
    "seedKeywords": [
        "home decor",
        "wedding ideas",
        "healthy recipes",
    ],
    "expansionMode": "seed_only",
    "includeCreators": False,
    "maxQueries": 10,
    "maxSuggestionsPerQuery": 12,
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/pinterest-keyword-suggestions-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 '{
  "seedKeywords": [
    "home decor",
    "wedding ideas",
    "healthy recipes"
  ],
  "expansionMode": "seed_only",
  "includeCreators": false,
  "maxQueries": 10,
  "maxSuggestionsPerQuery": 12,
  "maxResults": 10
}' |
apify call benthepythondev/pinterest-keyword-suggestions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Keyword Suggestions Scraper",
        "description": "Collect Pinterest autocomplete keywords and optional creator suggestions from seed terms, with alphabet expansion, ranks, URLs and profile metadata.",
        "version": "1.0",
        "x-build-id": "PNHl2CBdCeAtJmWYi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~pinterest-keyword-suggestions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-pinterest-keyword-suggestions-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/benthepythondev~pinterest-keyword-suggestions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-pinterest-keyword-suggestions-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/benthepythondev~pinterest-keyword-suggestions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-pinterest-keyword-suggestions-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",
                "properties": {
                    "seedKeywords": {
                        "title": "Seed keywords",
                        "type": "array",
                        "description": "Pinterest search phrases used as autocomplete seeds.",
                        "default": [
                            "home decor"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "expansionMode": {
                        "title": "Expansion mode",
                        "enum": [
                            "seed_only",
                            "alphabet"
                        ],
                        "type": "string",
                        "description": "Use each seed once, or append letters to discover additional long-tail suggestions.",
                        "default": "seed_only"
                    },
                    "includeCreators": {
                        "title": "Include creator suggestions",
                        "type": "boolean",
                        "description": "Also save public creator/profile suggestions returned beside keyword suggestions.",
                        "default": false
                    },
                    "maxQueries": {
                        "title": "Maximum expanded queries per seed",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety limit for each seed in alphabet mode. Seed-only mode uses one query per seed.",
                        "default": 10
                    },
                    "maxSuggestionsPerQuery": {
                        "title": "Maximum suggestions per query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum unique Pinterest suggestions saved from one autocomplete query.",
                        "default": 12
                    },
                    "maxResults": {
                        "title": "Maximum total results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique keyword and creator suggestions saved across the full run.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
