# Shopify Store Scraper — Products, Prices & Inventory (`avant_technologies/shopify-store-scraper`) Actor

Extract full product catalogs from any Shopify store: titles, prices, variants, SKUs, inventory, images. Fast JSON-endpoint extraction with automatic fallback.

- **URL**: https://apify.com/avant\_technologies/shopify-store-scraper.md
- **Developed by:** [Rushi Patel](https://apify.com/avant_technologies) (community)
- **Categories:** E-commerce, Lead generation, Other
- **Stats:** 2 total users, 0 monthly users, 33.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Store Scraper — Products, Prices & Inventory

Extract the full product catalog from any Shopify store — titles, prices, variants, SKUs, availability, images, tags, and more — with one clean dataset record per product, plus a per-store summary saved to the run's key-value store (so you're only charged for actual product records).

This is a fast, reliable **Shopify scraper** built for **product data extraction** at scale: point it at a store URL and get structured product data back. By default it uses Shopify's public JSON endpoints (no browser, no fuss), with an automatic multi-layer fallback so you keep getting data even when the easy path is closed.

---

### Sample output (real data)

Below is genuine data captured from live runs against `deathwishcoffee.com` and `mejuri.com`:

| Store | Title | Type | Price (min–max) | Currency | Variants | Images |
|---|---|---|---|---|---|---|
| Death Wish Coffee | Allfather's Aloha Button Up | Apparel | $40.00 | USD | 6 | 5 |
| Mejuri | (jewelry product) | Jewelry | $98–$398 | CAD | 1 | 5 |

One product record (trimmed):

```json
{
  "storeName": "Death Wish Coffee",
  "productId": 7492694540343,
  "title": "Allfather's Aloha Button Up",
  "vendor": "BAMKO",
  "productType": "Apparel",
  "priceMin": 40, "priceMax": 40, "currency": "USD",
  "tags": ["Apparel", "Men", "Merch"],
  "variants": [{"id": 42323014910007, "title": "S", "sku": "USHVJA02", "price": 40, "compareAtPrice": null, "available": false, "options": {"Size": "S"}}],
  "images": [{"src": "https://cdn.shopify.com/s/files/.../Front_Web2.jpg", "alt": null}],
  "url": "https://www.deathwishcoffee.com/products/allfathers-aloha-button-up-sold-out"
}
````

And the per-store summary (saved to the run's key-value store under `STORE_SUMMARIES`, so it isn't billed as a result):

```json
{"recordType":"store_summary","storeName":"Death Wish Coffee","productCount":291,"collectionCount":124,"priceRange":{"min":11.99,"max":40,"currency":"USD"},"currency":"USD","vendorList":["BAMKO"],"extractionPath":"products_json","status":"success"}
```

***

### Why this scraper — 3-layer reliability fallback

Most tools break the moment a store changes its configuration. When you **scrape a Shopify store** with this actor, it works down a chain of extraction strategies so you keep getting complete data:

1. **Primary — public `products.json` endpoint.** Fast, structured, page-based pagination, no browser required. This is the default path for most stores.
2. **Fallback — sitemap parsing.** If `products.json` is disabled, the actor parses `sitemap.xml` to discover product URLs, then extracts per-product JSON / JSON-LD.
3. **Last resort — opt-in headless browser (`useBrowser`).** For stores behind aggressive bot protection. This uses roughly 10x the compute and is **off by default** — you turn it on only when you need it.

Built to fail loudly, never silently:

- **Shopify detection first.** The actor confirms a URL is actually a Shopify store before doing anything else, and **fails fast with a clear, actionable message** if it isn't — it never silently returns garbage.
- **Password-protected / pre-launch stores are detected and reported**, so you always know why a store returned no products.
- **Transparent extraction path.** Every store's summary records exactly which path was used (`extractionPath`), so you can audit how each result was obtained.

#### Completeness

One record per product with the fields you actually need for **shopify price monitoring** and **ecommerce scraper** workflows: full variant breakdowns, SKUs, availability, compare-at pricing, images with alt text, tags, vendor, product type, and timestamps — plus a store-level summary for the whole catalog.

#### Transparent, per-result pricing

Flat **pay-per-result** pricing you can predict before you press Start. No monthly rental, no surprise platform-usage bills. See [Pricing](#pricing).

***

### Input

Fill in only `storeUrls` and you'll get the full catalog with sensible defaults.

| Field | Type | Default | Description |
|---|---|---|---|
| `storeUrls` | array of strings | — (**required**) | Shopify store root URLs, e.g. `https://www.allbirds.com` |
| `scope` | enum: `all_products` | `collections` | `single_products` | `all_products` | What to extract |
| `collectionHandles` | array | optional | Used with `scope=collections`; empty = all collections |
| `productUrls` | array | optional | Used with `scope=single_products` |
| `includeVariants` | boolean | `true` | Include per-variant data |
| `includeImages` | boolean | `true` | Include product images |
| `maxProductsPerStore` | integer | `0` (unlimited) | Cap products per store |
| `useBrowser` | boolean | `false` | Opt-in headless browser for stores behind aggressive bot protection (~10x compute) |
| `useResidentialProxy` | boolean | `false` | Route requests through residential proxy |

***

### Output

One dataset record per product. A per-store `store_summary` is saved to the run's key-value store (`STORE_SUMMARIES`) — **you're only charged for product records, not summaries.**

**Per-product record:**

`storeUrl`, `storeName`, `productId`, `handle`, `title`, `description` (plain text, HTML stripped), `vendor`, `productType`, `tags[]`, `createdAt`, `updatedAt`, `publishedAt`, `priceMin`, `priceMax`, `currency`, `totalInventory` (usually `null` — public endpoints rarely expose inventory), `variants[]` `{id, title, sku, price, compareAtPrice, available, inventoryQuantity, options}`, `images[]` `{src, alt}`, `url`, `scrapedAt`.

> Currency is reported **as-is and never converted**.

**Per-store summary** (key-value store, key `STORE_SUMMARIES`):

```json
{
  "recordType": "store_summary",
  "storeUrl": "...",
  "storeName": "...",
  "productCount": 291,
  "collectionCount": 124,
  "priceRange": { "min": 11.99, "max": 40, "currency": "USD" },
  "currency": "USD",
  "vendorList": ["BAMKO"],
  "extractionPath": "products_json",
  "status": "success",
  "scrapedAt": "..."
}
```

***

### Quickstart

1. Paste one or more store URLs into `storeUrls`.
2. Click **Start**.
3. Get one row per product; the per-store summary is in the run's key-value store.

Minimal input:

```json
{ "storeUrls": ["https://www.allbirds.com"] }
```

That's it — filling only `storeUrls` produces the full product catalog with defaults applied.

***

### Scheduling recipe — monitor competitor prices weekly

Turn this into a hands-off **shopify price monitoring** pipeline:

1. Add your competitors' store URLs to `storeUrls`.
2. Create an **Apify Schedule** that runs this actor every Monday.
3. Between runs, diff `priceMin` / `priceMax` per `productId` to catch price changes.

Wire it into your stack with **Apify Schedules + integrations** — for example, a webhook that pushes changes to **Slack** or appends new rows to **Google Sheets** — so price movements land where your team already works.

***

### Pricing

**Pay-per-result: $2.50 per 1,000 products.**

Transparent, flat, and predictable — no monthly rental and no surprise platform-usage bills. You know your cost before you run.

The value here is **reliability + predictable pricing**: the 3-layer fallback keeps results flowing, and the per-result model means you pay for products, not for platform time. (Browser mode is more compute-intensive and is **opt-in** — it's off unless you enable `useBrowser`.)

***

### FAQ

**"It says my store isn't Shopify."**
The actor detects whether a URL is actually a Shopify store before extracting, and fails fast with a clear message if it can't confirm one. If you're certain the site is Shopify but it's behind bot protection, enable `useResidentialProxy` and/or `useBrowser` and try again.

**What happens with password-protected or pre-launch stores?**
They're detected and reported in the store summary. You'll get a clear status explaining why no products were returned, rather than an empty result with no explanation.

**Why is `totalInventory` (and often `inventoryQuantity`) null?**
Public Shopify endpoints rarely expose inventory figures, so these fields are usually `null`. This reflects what the store makes publicly available.

**How is non-USD currency handled?**
Currency is reported exactly as the store lists it (e.g. `CAD` for Mejuri) and is **never converted**. Handle any conversion downstream if you need a single currency.

**Can it handle very large stores?**
Yes. Results are streamed per page as they're extracted. Use `maxProductsPerStore` to cap how many products you pull from each store when you don't need the whole catalog.

**Can I scrape a specific collection?**
Yes. Set `scope=collections` and list the collection handles in `collectionHandles`. Leave `collectionHandles` empty to scrape all collections.

**How do pagination and de-duplication work?**
The primary path uses page-based pagination against `products.json`. Products are **de-duplicated by `productId` per store**, so you get one clean record per product even across paginated pages.

**Do I need to enable the browser?**
No — the browser is opt-in. Most stores are handled by the fast public-JSON and sitemap paths. Only enable `useBrowser` for stores behind aggressive bot protection, and expect roughly 10x the compute cost when you do.

***

#### Keywords

Shopify scraper · Shopify product scraper · scrape Shopify store · Shopify price monitoring · ecommerce scraper · product data extraction.

# Actor input Schema

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

Shopify store root URLs, e.g. https://www.allbirds.com. One record is produced per product, plus a summary per store.

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

What to scrape from each store.

## `collectionHandles` (type: `array`):

Only with scope=collections. Collection handles (the slug in /collections/{handle}). Leave empty to scrape every collection.

## `productUrls` (type: `array`):

Only with scope=single\_products. Full product page URLs, e.g. https://store.com/products/some-handle.

## `includeVariants` (type: `boolean`):

Include the full variants array (id, sku, price, compareAtPrice, availability, options) on each product.

## `includeImages` (type: `boolean`):

Include the images array (src + alt) on each product.

## `maxProductsPerStore` (type: `integer`):

Cap the number of products per store. 0 = unlimited.

## `useBrowser` (type: `boolean`):

Enable the headless-browser fallback for stores behind aggressive bot protection. ~10x the compute cost — leave off unless a store fails without it.

## `useResidentialProxy` (type: `boolean`):

Route requests through Apify residential proxy. Helps with stores that block datacenter IPs.

## Actor input object example

```json
{
  "storeUrls": [
    "https://www.allbirds.com",
    "https://www.mejuri.com"
  ],
  "scope": "all_products",
  "collectionHandles": [
    "mens",
    "sale"
  ],
  "productUrls": [
    "https://www.allbirds.com/products/mens-wool-runners"
  ],
  "includeVariants": true,
  "includeImages": true,
  "maxProductsPerStore": 0,
  "useBrowser": false,
  "useResidentialProxy": false
}
```

# Actor output Schema

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

One dataset record per product. A per-store summary is in the run's key-value store (STORE\_SUMMARIES).

# 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 = {
    "storeUrls": [
        "https://www.deathwishcoffee.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("avant_technologies/shopify-store-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 = { "storeUrls": ["https://www.deathwishcoffee.com"] }

# Run the Actor and wait for it to finish
run = client.actor("avant_technologies/shopify-store-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 '{
  "storeUrls": [
    "https://www.deathwishcoffee.com"
  ]
}' |
apify call avant_technologies/shopify-store-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Scraper — Products, Prices & Inventory",
        "description": "Extract full product catalogs from any Shopify store: titles, prices, variants, SKUs, inventory, images. Fast JSON-endpoint extraction with automatic fallback.",
        "version": "0.1",
        "x-build-id": "g1knhstzUx2T01bZa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/avant_technologies~shopify-store-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-avant_technologies-shopify-store-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/avant_technologies~shopify-store-scraper/runs": {
            "post": {
                "operationId": "runs-sync-avant_technologies-shopify-store-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/avant_technologies~shopify-store-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-avant_technologies-shopify-store-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "Store URLs",
                        "type": "array",
                        "description": "Shopify store root URLs, e.g. https://www.allbirds.com. One record is produced per product, plus a summary per store.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scope": {
                        "title": "Scope",
                        "enum": [
                            "all_products",
                            "collections",
                            "single_products"
                        ],
                        "type": "string",
                        "description": "What to scrape from each store.",
                        "default": "all_products"
                    },
                    "collectionHandles": {
                        "title": "Collection handles",
                        "type": "array",
                        "description": "Only with scope=collections. Collection handles (the slug in /collections/{handle}). Leave empty to scrape every collection.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Only with scope=single_products. Full product page URLs, e.g. https://store.com/products/some-handle.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeVariants": {
                        "title": "Include variants",
                        "type": "boolean",
                        "description": "Include the full variants array (id, sku, price, compareAtPrice, availability, options) on each product.",
                        "default": true
                    },
                    "includeImages": {
                        "title": "Include images",
                        "type": "boolean",
                        "description": "Include the images array (src + alt) on each product.",
                        "default": true
                    },
                    "maxProductsPerStore": {
                        "title": "Max products per store",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of products per store. 0 = unlimited.",
                        "default": 0
                    },
                    "useBrowser": {
                        "title": "Use browser (last resort)",
                        "type": "boolean",
                        "description": "Enable the headless-browser fallback for stores behind aggressive bot protection. ~10x the compute cost — leave off unless a store fails without it.",
                        "default": false
                    },
                    "useResidentialProxy": {
                        "title": "Use residential proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify residential proxy. Helps with stores that block datacenter IPs.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```