# Pinterest Shopify Finder + Find Lead (`beige_equality/pinterest-shopify-finder`) Actor

- **URL**: https://apify.com/beige\_equality/pinterest-shopify-finder.md
- **Developed by:** [War tail](https://apify.com/beige_equality) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 → Shopify Store Finder

Find **Shopify stores that are active on Pinterest** for a given set of keywords.

The actor searches Pinterest by keyword, follows the **destination link** of each pin
(both organic and promoted pins appear in search results), de-duplicates the domains,
and keeps only the ones that are detected as **Shopify** stores.

> ⚠️ **Important about "ads"**
> Pinterest has **no public, keyword-searchable ads library** (its Ads Transparency
> Center is EU-only and searchable *by advertiser name*, not freely by keyword).
> So this actor returns stores **active on Pinterest for your keywords** — a blend of
> organic and promoted pins — not a clean "paid ads only" list. That is the most
> reliable result obtainable from public data.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `keywords` | string[] | — (required) | Search terms; each is searched independently. |
| `maxPinsPerKeyword` | integer | 120 | Pins to scan per keyword before stopping. |
| `onlyShopify` | boolean | true | Drop destination domains that are not Shopify (or below `minConfidence`) from the output. |
| `minConfidence` | `low`\|`medium`\|`high` | `low` | Minimum Shopify confidence to keep when `onlyShopify` is on. See [detection](#how-shopify-detection-works). |
| `checkProductsJson` | boolean | false | Extra confirmation via `<domain>/products.json` (counts as a strong signal). |
| `extractContacts` | boolean | true | For each kept store, scrape a contact email + phone (homepage first, then contact/policies/about pages only if needed). See [contact extraction](#contact-extraction). |
| `maxConcurrency` | integer | 10 | Parallel domain checks. |
| `keywordConcurrency` | integer | 1 | Keywords searched on Pinterest in parallel. Keep low to avoid rate limiting. |
| `maxRequestRetries` | integer | 3 | Retries with exponential backoff on `429`/`5xx` before giving up on a request. |
| `proxyConfiguration` | object | Apify RESIDENTIAL | Proxy settings. A fresh IP is used per request. |

Example:

```json
{
  "keywords": ["home decor", "minimalist jewelry"],
  "maxPinsPerKeyword": 150,
  "onlyShopify": true,
  "minConfidence": "medium",
  "checkProductsJson": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

### Output

One dataset item per store:

```json
{
  "domain": "examplestore.com",
  "storeUrl": "https://examplestore.com/",
  "finalDomain": "examplestore.com",
  "isShopify": true,
  "confidence": "high",
  "detectedVia": ["header:x-shopid", "body:cdn.shopify.com"],
  "matchedKeywords": ["home decor", "boho cushions"],
  "pinCount": 7,
  "email": "hello@examplestore.com",
  "phone": "+15551234567",
  "emails": ["hello@examplestore.com", "support@examplestore.com"],
  "phones": ["+15551234567"],
  "destinationLink": "https://examplestore.com/products/cushion",
  "samplePinUrl": "https://www.pinterest.com/pin/123456789/",
  "samplePinTitle": "Boho cushion cover",
  "scrapedAt": "2026-06-19T10:00:00.000Z"
}
```

`pinCount` and `matchedKeywords` are aggregated across all keywords: each store
appears once, with every keyword whose pins pointed to it and the total number of
pins seen. `finalDomain` is the host after following redirects. `email`/`phone`
are the best single contact picked from the de-duplicated `emails`/`phones`
lists (or `null` when none was found); they are present only when
`extractContacts` is on.

### How Shopify detection works

Each domain is graded by the **strength** of the signals it emits:

- **Strong signals** → `high` confidence:
  - **Headers/cookies** — `x-shopid`, `x-shopify-stage`, `x-sorting-hat-shopid`, `x-shardid`, `powered-by: Shopify`, `_shopify`/`_secure_session_id` cookies.
  - **Redirect** — the final host ends in `myshopify.com`.
  - **`/products.json`** (when `checkProductsJson` is on) — returns a valid `products` array.
  - **Canonical body marker** — `myshopify.com` appears in the HTML.
- **Weak signals** (generic body markers — `cdn.shopify.com`, `/cdn/shop/`, `Shopify.theme`, `window.Shopify`):
  - two or more → `medium` confidence,
  - exactly one → `low` confidence (e.g. a site merely embedding a Shopify buy-button).

Set `minConfidence` to trade recall for precision. Marketplaces and socials
(Amazon, Etsy, eBay, AliExpress, Instagram, etc.) are filtered out before detection.

### Contact extraction

When `extractContacts` is on (default), each **kept** store is enriched with a
contact email and phone. Signals are graded by reliability:

1. `mailto:` / `tel:` links — taken first,
2. JSON-LD structured data (`email`, `telephone`, `contactPoint`),
3. bare addresses in the page text, filtered hard against placeholders
   (`you@example.com`), platform domains (`*.myshopify.com`, `sentry.io`…),
   asset URLs (`logo@2x.png`) and junk phone runs (order numbers, years, SKUs).

It **reuses the homepage HTML already downloaded during detection** (no extra
request), then walks the usual Shopify contact pages (`/pages/contact`,
`/policies/contact-information`, `/pages/about`…) **only if** an email or phone
is still missing, stopping as soon as both are found. Contacts are scraped only
for stores that pass the `onlyShopify` / `minConfidence` filter, so no request
is spent on stores you're about to drop. Turn `extractContacts` off to run
leaner (fewer requests, lower proxy cost).

### Pricing & cost control (pay-per-event)

The actor is billed per result: every store written to the dataset charges the
`apify-default-dataset-item` event. The Apify SDK stops pushing once the run's
`maxTotalChargeUsd` is reached, and the actor additionally **stops detection and
contact scraping early** once that result budget is exhausted — so it never
keeps spending proxy on stores it could no longer bill. Because Pinterest
requires residential proxies (the dominant cost), price the result event to
comfortably exceed your per-store cost, and consider `extractContacts: false`
or a lower `minConfidence` to control spend.

### Deploy / publish on Apify

**Option A — Apify CLI**

```bash
npm install -g apify-cli
apify login
cd pinterest-shopify-finder
apify push          # builds and uploads the actor to your account
```

Then open the actor in the Apify Console → **Publish** tab → set category, pricing, and make it public.

**Option B — GitHub import**
Push this folder to a GitHub repo, then in the Apify Console:
**Create new → Link Git repository** → point it at the repo → Build.

### Development

```bash
npm install
npm test          # node:test unit tests (pure helpers, no network)
```

The pure logic — domain normalization, host filtering, response parsing,
Shopify signal grading, contact email/phone parsing, backoff timing, the
concurrency pool — is covered by unit tests in `test/`. The networked layers
(`searchPinterestDomains`, `detectShopify`, `extractContacts`) compose those
tested helpers.

### Notes & limitations

- **Residential proxies are strongly recommended.** Pinterest blocks datacenter IPs.
  A fresh proxy IP is used per request, and transient `429`/`5xx` responses are retried with exponential backoff.
- Pinterest's internal search endpoint is unofficial and changes occasionally. If results
  drop to zero, only `src/pinterest.js` needs updating (response parsing / headers).
- Detection is heuristic; `checkProductsJson: true` reduces false positives.
- Respect Pinterest's and target sites' terms of service and applicable law in your jurisdiction.

### Project structure

```
pinterest-shopify-finder/
├── .actor/
│   ├── actor.json          # actor metadata
│   ├── input_schema.json   # input form
│   ├── dataset_schema.json # output table view
│   └── output_schema.json  # run output (dataset links)
├── .github/
│   └── workflows/ci.yml    # syntax + JSON validation + unit tests on push/PR
├── examples/
│   └── input.example.json  # sample input
├── src/
│   ├── main.js             # orchestration + pay-per-event budget guard
│   ├── pinterest.js        # Pinterest keyword search → candidate domains
│   ├── shopify.js          # Shopify detection + confidence scoring
│   ├── contacts.js         # contact email / phone extraction
│   ├── http.js             # proxy rotation + retry/backoff
│   └── pool.js             # ordered concurrency pool
├── test/                   # node:test unit tests for the pure helpers
├── Dockerfile
├── .dockerignore
├── .editorconfig
├── .gitignore
├── LICENSE
├── package.json
└── README.md
```

### License

MIT — see [LICENSE](./LICENSE).

# Actor input Schema

## `keywords` (type: `array`):

Search terms to look up on Pinterest. Each term is searched independently.

## `maxPinsPerKeyword` (type: `integer`):

How many pins to scan per keyword before stopping. More pins = more candidate domains, higher cost.

## `onlyShopify` (type: `boolean`):

If on, destination domains that are not detected as Shopify (or below the minimum confidence) are dropped from the output.

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

When 'Only output Shopify stores' is on, keep only matches at this confidence or higher. 'low' accepts a single weak body marker (may include sites that merely embed a Shopify widget); 'medium' requires two weak markers; 'high' requires a strong signal (headers, cookies, redirect to myshopify.com, or products.json).

## `checkProductsJson` (type: `boolean`):

Extra confirmation step: fetch <domain>/products.json. A valid response is a strong (high-confidence) signal. Reduces false positives but adds one request per domain.

## `extractContacts` (type: `boolean`):

For each store kept, scrape a contact email and phone number — from the homepage first, then the contact / policies / about pages only if needed. Short-circuits as soon as both are found. Adds requests per store; turn off to run leaner.

## `maxConcurrency` (type: `integer`):

How many destination domains to check for Shopify in parallel.

## `keywordConcurrency` (type: `integer`):

How many keywords to search on Pinterest in parallel. Keep low (1–2) to reduce the chance of Pinterest rate-limiting your proxies.

## `maxRequestRetries` (type: `integer`):

Retries (with exponential backoff) on transient errors and rate limiting (429 / 5xx) before giving up on a request.

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

Pinterest aggressively blocks datacenter IPs — residential proxies are strongly recommended. A fresh proxy IP is used per request.

## Actor input object example

```json
{
  "keywords": [
    "skincare",
    "pet accessories"
  ],
  "maxPinsPerKeyword": 120,
  "onlyShopify": true,
  "minConfidence": "low",
  "checkProductsJson": false,
  "extractContacts": true,
  "maxConcurrency": 10,
  "keywordConcurrency": 1,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per destination domain kept after Shopify detection, with all fields: domain, store URL, confidence, detection signals, matched keywords, pin count, contact email/phone and a sample pin.

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

The curated 'overview' columns from the dataset schema. Pick CSV/Excel in the export options to download as a spreadsheet.

# 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 = {
    "keywords": [
        "home decor",
        "minimalist jewelry"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("beige_equality/pinterest-shopify-finder").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 = { "keywords": [
        "home decor",
        "minimalist jewelry",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("beige_equality/pinterest-shopify-finder").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 '{
  "keywords": [
    "home decor",
    "minimalist jewelry"
  ]
}' |
apify call beige_equality/pinterest-shopify-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pinterest Shopify Finder + Find Lead",
        "version": "0.0",
        "x-build-id": "iK747u0a9JMyFpT8k"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/beige_equality~pinterest-shopify-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-beige_equality-pinterest-shopify-finder",
                "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/beige_equality~pinterest-shopify-finder/runs": {
            "post": {
                "operationId": "runs-sync-beige_equality-pinterest-shopify-finder",
                "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/beige_equality~pinterest-shopify-finder/run-sync": {
            "post": {
                "operationId": "run-sync-beige_equality-pinterest-shopify-finder",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Search terms to look up on Pinterest. Each term is searched independently.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPinsPerKeyword": {
                        "title": "Max pins per keyword",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "How many pins to scan per keyword before stopping. More pins = more candidate domains, higher cost.",
                        "default": 120
                    },
                    "onlyShopify": {
                        "title": "Only output Shopify stores",
                        "type": "boolean",
                        "description": "If on, destination domains that are not detected as Shopify (or below the minimum confidence) are dropped from the output.",
                        "default": true
                    },
                    "minConfidence": {
                        "title": "Minimum Shopify confidence",
                        "enum": [
                            "low",
                            "medium",
                            "high"
                        ],
                        "type": "string",
                        "description": "When 'Only output Shopify stores' is on, keep only matches at this confidence or higher. 'low' accepts a single weak body marker (may include sites that merely embed a Shopify widget); 'medium' requires two weak markers; 'high' requires a strong signal (headers, cookies, redirect to myshopify.com, or products.json).",
                        "default": "low"
                    },
                    "checkProductsJson": {
                        "title": "Deep-confirm via /products.json",
                        "type": "boolean",
                        "description": "Extra confirmation step: fetch <domain>/products.json. A valid response is a strong (high-confidence) signal. Reduces false positives but adds one request per domain.",
                        "default": false
                    },
                    "extractContacts": {
                        "title": "Scrape contact email & phone",
                        "type": "boolean",
                        "description": "For each store kept, scrape a contact email and phone number — from the homepage first, then the contact / policies / about pages only if needed. Short-circuits as soon as both are found. Adds requests per store; turn off to run leaner.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Domain-check concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many destination domains to check for Shopify in parallel.",
                        "default": 10
                    },
                    "keywordConcurrency": {
                        "title": "Keyword-search concurrency",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many keywords to search on Pinterest in parallel. Keep low (1–2) to reduce the chance of Pinterest rate-limiting your proxies.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Retries (with exponential backoff) on transient errors and rate limiting (429 / 5xx) before giving up on a request.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Pinterest aggressively blocks datacenter IPs — residential proxies are strongly recommended. A fresh proxy IP is used per request.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```