# Shopify Price Monitor — Track Price Changes & Alerts (`bikram07/shopify-price-monitor`) Actor

Track competitor prices on any public Shopify store via the official products.json API — no scraping, no proxies. Alert mode outputs only products whose price changed, so you pay only for real changes. Schedule it daily for automatic price-change alerts. $1 per 1,000 products.

- **URL**: https://apify.com/bikram07/shopify-price-monitor.md
- **Developed by:** [Bikram](https://apify.com/bikram07) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Shopify Price Monitor — Competitor Price Tracker & Change Alerts

**Track competitor prices on any public Shopify store** using the free, official [`/products.json`](https://shopify.dev) endpoint — no scraping, no Cloudflare, no proxies, no browser. Point it at one or more stores, turn on **alert mode**, and schedule it daily to get automatic competitor price intelligence delivered to your webhook, Slack, email, Make/Zapier, or database.

> Primary keywords: Shopify price monitor · Shopify price tracker · competitor price monitoring · Shopify products.json scraper · price change alerts

### What it does

Fetches the full product catalogue of any public Shopify store via its first-party `/products.json` API and outputs clean, structured product + variant data. In **alert mode**, it remembers prices from previous runs and outputs **only the products whose price changed** — so you get signal, not noise, and pay only for real changes.

### How it works

1. You provide one or more Shopify store URLs (custom domains or `.myshopify.com`).
2. The Actor calls each store's public `/products.json` endpoint and paginates through the whole catalogue automatically (250 products per page, via the `Link` header).
3. Each raw product is normalized into a consistent schema with all variants, prices, and `compareAtPrice`.
4. In **alert mode**, it compares each variant price against the last run's snapshot (stored per store in an Apify key-value store) and emits only changed / new products.
5. Results are written to the dataset — export to JSON/CSV/Excel or pipe to a webhook.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `storeUrls` | array | yes | Shopify store URLs — e.g. `allbirds.com`, `gymshark.com`, `mystore.myshopify.com`. Any format accepted; the path is stripped automatically. |
| `maxProducts` | integer | no | Max products to output per run, across all stores (default: 500, max: 50,000). |
| `alertMode` | boolean | no | Only output products where a variant price changed since the last run (default: false). |
| `deltaOnly` | boolean | no | In alert mode, output only changed products with a change summary (default: true). |
| `minPriceChangePct` | number | no | Minimum % change to report — filters out sub-threshold fluctuations (default: 0 = report every change). |

**Example — snapshot all products from a store:**
```json
{
    "storeUrls": ["allbirds.com", "gymshark.com"],
    "maxProducts": 2000,
    "alertMode": false
}
````

**Example — daily price-change alerts only:**

```json
{
    "storeUrls": ["competitor-store.com"],
    "alertMode": true,
    "deltaOnly": true,
    "minPriceChangePct": 1.0
}
```

### Output fields

Each product is one dataset item:

| Field | Type | Description |
|---|---|---|
| `productId` | string | Shopify product ID |
| `handle` | string | URL slug of the product |
| `title` | string | Product title |
| `productType` | string | Shopify product type/category |
| `vendor` | string | Brand / vendor name |
| `tags` | array | Product tags |
| `publishedAt` | string | ISO date the product was published |
| `updatedAt` | string | ISO date the product was last updated |
| `url` | string | Full product page URL |
| `storeDomain` | string | Store hostname (e.g. `allbirds.com`) |
| `storeUrl` | string | Store base URL |
| `featuredImage` | string | null | First product image URL |
| `variantCount` | integer | Number of variants |
| `lowestPrice` | string | null | Lowest price across in-stock variants |
| `currency` | null | Not exposed by `/products.json` — always `null` (see limitations) |
| `variants` | array | Per-variant detail (see below) |
| `priceChanges` | array | null | Changed variants in alert mode; `null` in snapshot mode |
| `changedVariantCount` | integer | null | Count of changed variants in alert mode |
| `scrapedAt` | string | ISO timestamp of this run |

**Each item in `variants`:**

| Field | Type | Description |
|---|---|---|
| `variantId` | string | Shopify variant ID |
| `title` | string | Variant title (e.g. `US 9 / Natural White`) |
| `sku` | string | SKU (empty string if none) |
| `price` | string | Current price |
| `compareAtPrice` | string | null | Original / crossed-out "compare at" price |
| `available` | boolean | In-stock flag |
| `inventoryQuantity` | integer | null | Inventory count when the store exposes it |

**Example item:**

```json
{
    "productId": "7845123456789",
    "handle": "mens-natural-wool-runner",
    "title": "Men's Natural Wool Runner",
    "productType": "Shoes",
    "vendor": "Allbirds",
    "tags": ["mens", "running", "wool"],
    "publishedAt": "2024-01-15T10:30:00-05:00",
    "updatedAt": "2026-06-12T08:22:00-05:00",
    "url": "https://allbirds.com/products/mens-natural-wool-runner",
    "storeDomain": "allbirds.com",
    "storeUrl": "https://allbirds.com",
    "featuredImage": "https://cdn.shopify.com/s/files/...",
    "variantCount": 8,
    "lowestPrice": "110.0",
    "currency": null,
    "variants": [
        {
            "variantId": "43891234567890",
            "title": "US 9 / Natural White",
            "sku": "FW22M-WR-NWH-090",
            "price": "110.00",
            "compareAtPrice": "130.00",
            "available": true,
            "inventoryQuantity": 42
        }
    ],
    "priceChanges": [
        {
            "variantId": "43891234567890",
            "title": "US 9 / Natural White",
            "price": "110.00",
            "oldPrice": "130.00",
            "changePercent": -15.38,
            "changeType": "decreased"
        }
    ],
    "changedVariantCount": 1,
    "scrapedAt": "2026-06-14T04:30:00.000Z"
}
```

In **alert mode**, `priceChanges` lists only variants that changed, each with `oldPrice`, `changePercent`, and `changeType` — one of `increased`, `decreased`, `added` (new variant), or `new_product` (first time the product was seen).

### Use cases

- **E-commerce store owner** — watch your top 5 competitors daily and react when they discount, so you never get undercut without knowing.
- **Dropshipper** — track supplier Shopify stores for price changes and restocks before you commit a customer order.
- **Pricing / category manager** — pull a full catalogue snapshot for spreadsheet analysis of a competitor's price architecture and discount depth.
- **Deal / arbitrage hunter** — detect price drops across multiple stores and flag arbitrage gaps automatically.
- **AI agent / data pipeline** — feed structured Shopify price data to Claude, Cursor, or your own app via Apify's API or MCP server.

### Setting up daily price alerts

1. Set your `storeUrls`, enable `alertMode: true`, optionally set `minPriceChangePct: 1`.
2. Create an [Apify Schedule](https://docs.apify.com/platform/schedules) to run the Actor daily.
3. Add a [webhook](https://docs.apify.com/platform/integrations/webhooks): Slack, email, Make/Zapier, or your database.
4. Each run outputs **only products with price changes since the previous run**.

Price history is remembered per store. The **first run always outputs every product** to establish the baseline; subsequent runs output only changes.

### Pricing — $1 per 1,000 products

This Actor uses Apify's **pay-per-event** model. You are charged per product written to the dataset — nothing else.

| Event | Price | When charged |
|---|---|---|
| `shopify-product` | $0.001 | Each product written to the dataset |

- That's **$1 per 1,000 products**.
- In alert mode, unchanged products are never written and never charged.
- A scheduled run that detects no price changes writes nothing and **charges $0**.
- No monthly fee, no platform rental on top of these events.

### Use from Claude, Cursor & AI agents (MCP)

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/sse?actors=bikram07/shopify-price-monitor",
            "headers": {
                "Authorization": "Bearer YOUR_APIFY_TOKEN"
            }
        }
    }
}
```

Ask your agent: *"Check if any prices changed at gymshark.com since yesterday."*

Or call the API directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/bikram07~shopify-price-monitor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"storeUrls": ["allbirds.com"], "maxProducts": 100, "alertMode": false}'
```

### FAQ

**Is this a subscription?**
No. It's pay-per-event — you're charged $0.001 per product written ($1 per 1,000 products), and nothing when no products are written. There's no monthly fee and no minimum.

**How does the pricing / refund work?**
You pay only for products actually written to your dataset. In alert mode a run with no price changes writes nothing and costs $0. Billing is handled by the Apify platform; refunds and platform usage are governed by [Apify's billing terms](https://apify.com/pricing).

**Does it use official APIs, or is it scraping?**
It uses Shopify's first-party, public `/products.json` endpoint — the same JSON Shopify storefronts themselves consume. No HTML parsing, no headless browser, no proxy farm, no Cloudflare bypass.

**Does it work on custom domains (not `.myshopify.com`)?**
Yes. Any public Shopify store — custom domain like `allbirds.com` or the default `.myshopify.com` subdomain — exposes `/products.json`. The Actor auto-detects and handles both.

**How many products can it handle?**
Up to 50,000 per run (`maxProducts: 50000`). Large catalogues work fine — pagination is automatic.

**Can I monitor multiple stores in one run?**
Yes. List as many URLs as you want in `storeUrls`. Price history is tracked separately per store.

**What's `compareAtPrice`?**
Shopify's "compare at price" is the original, crossed-out reference price shown during sales. The Actor captures it per variant alongside the current price, so you can see both the sale price and the regular price.

### What it does NOT do (limitations)

- **Public stores only.** Password-protected stores return 401/403 on `/products.json`; the Actor logs a warning and skips them.
- **No currency field.** Shopify's `/products.json` does not expose the store currency, so `currency` is always `null`. Prices are returned as the store's native numeric strings.
- **Catalogue data only.** It reads what `/products.json` exposes (products, variants, prices, availability, images, tags). It does not access checkout, customer, order, or admin data.
- **Snapshot cadence, not real-time.** Price history is built run-over-run; "changes" are detected between scheduled runs, not as a live stream.
- **`inventoryQuantity` is best-effort.** It's included only when the store chooses to expose it on `/products.json`; otherwise it's `null`.

### Related searches

Shopify price scraper · Shopify competitor price monitor · Shopify price tracker · Shopify product tracker · e-commerce price intelligence · Shopify `/products.json` API · Shopify price change alert · competitor price monitoring tool · Shopify store scraper API · dropship price tracker

***

Uses the Shopify public storefront `/products.json` endpoint. Not affiliated with Shopify Inc.

# Actor input Schema

## `storeUrls` (type: `array`):

One or more public Shopify store URLs to monitor. Accepts any format: <b>mystore.myshopify.com</b>, <b>https://custom-domain.com</b>, etc. The store must have its product catalogue public (no password protection).

## `maxProducts` (type: `integer`):

Maximum total products to output across all stores in this run.

## `alertMode` (type: `boolean`):

When enabled, the Actor remembers product prices from previous runs and only outputs products where at least one variant price has changed. Run on a schedule for continuous price intelligence. Only changed products are charged.

## `deltaOnly` (type: `boolean`):

In alert mode, set this to <b>true</b> (default) to output only the changed variant details. Set to <b>false</b> to include the full product with all variants alongside the change summary.

## `minPriceChangePct` (type: `number`):

Filter out tiny price fluctuations. Only report a price change if it is at least this many percent. Set to 0 (default) to report every change.

## Actor input object example

```json
{
  "maxProducts": 500,
  "alertMode": false,
  "deltaOnly": true,
  "minPriceChangePct": 0
}
```

# 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("bikram07/shopify-price-monitor").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("bikram07/shopify-price-monitor").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 bikram07/shopify-price-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Price Monitor — Track Price Changes & Alerts",
        "description": "Track competitor prices on any public Shopify store via the official products.json API — no scraping, no proxies. Alert mode outputs only products whose price changed, so you pay only for real changes. Schedule it daily for automatic price-change alerts. $1 per 1,000 products.",
        "version": "0.1",
        "x-build-id": "wCQUSSAUE2JmfZzLm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bikram07~shopify-price-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bikram07-shopify-price-monitor",
                "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/bikram07~shopify-price-monitor/runs": {
            "post": {
                "operationId": "runs-sync-bikram07-shopify-price-monitor",
                "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/bikram07~shopify-price-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-bikram07-shopify-price-monitor",
                "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": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "Shopify store URLs",
                        "type": "array",
                        "description": "One or more public Shopify store URLs to monitor. Accepts any format: <b>mystore.myshopify.com</b>, <b>https://custom-domain.com</b>, etc. The store must have its product catalogue public (no password protection).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Max products per run",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum total products to output across all stores in this run.",
                        "default": 500
                    },
                    "alertMode": {
                        "title": "Alert mode (only new / changed products)",
                        "type": "boolean",
                        "description": "When enabled, the Actor remembers product prices from previous runs and only outputs products where at least one variant price has changed. Run on a schedule for continuous price intelligence. Only changed products are charged.",
                        "default": false
                    },
                    "deltaOnly": {
                        "title": "Delta only (skip unchanged variants)",
                        "type": "boolean",
                        "description": "In alert mode, set this to <b>true</b> (default) to output only the changed variant details. Set to <b>false</b> to include the full product with all variants alongside the change summary.",
                        "default": true
                    },
                    "minPriceChangePct": {
                        "title": "Minimum price change % to report",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "number",
                        "description": "Filter out tiny price fluctuations. Only report a price change if it is at least this many percent. Set to 0 (default) to report every change.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```