# Zepto Product Scraper - Prices, MRP, Stock by Location (`memo23/zepto-product-scraper`) Actor

Scrape Zepto product listings for any delivery location in India — name, brand, price, MRP, discount, pack size, stock, rating and image. Search by keyword or paste category/product URLs. Compare prices across cities. JSON, CSV or Excel out, billed per product.

- **URL**: https://apify.com/memo23/zepto-product-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 products

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Zepto Product Scraper

Turn [Zepto](https://www.zepto.com) — India's 10-minute grocery app — into structured product data for **any delivery location**. Search by keyword, or paste category / product URLs, and get one clean row per product with **price, MRP, discount, pack size, stock, rating and image** — tagged with the location it was priced for.

Built for price monitoring, competitor tracking and quick-commerce market research across India.

#### How it works

![How the Zepto Product Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-zepto.png)

#### ✨ Why use this scraper?

- **Real, location-specific prices** — Zepto stock and prices vary by store, so every row is tagged with the delivery location it was scraped for. Run multiple cities to compare.
- **Three ways in** — keyword search, category URLs, or direct product URLs. Mix them in one run.
- **Rich product rows** — name, brand, MRP, selling price, discount %, Zepto Pass price, pack size, unit, stock, rating, category and images.
- **Prices in ₹, not paise** — converted and clean, ready for a sheet.
- **No login, no browser, no captcha** — talks to Zepto's own app API directly; fast and cheap to run.
- **JSON, CSV, Excel or API** — pipe straight into your BI tool, sheet or pipeline. Billed per product.

#### 🎯 Use cases

| You are a… | Use it to… |
|---|---|
| Brand / FMCG team | Track your SKUs' prices, discounts and availability across cities on Zepto |
| Competitor analyst | Compare a category's pricing between Zepto stores / cities |
| Quick-commerce researcher | Measure assortment, discount depth and stock-outs over time |
| Pricing / revenue team | Feed live competitor prices into dynamic-pricing models |
| Data / app builder | Seed a grocery price-comparison product with structured rows |

#### 📥 Supported inputs

| Input | Example | What it does |
|---|---|---|
| Location (required) | `Koramangala, Bengaluru` or `12.9352,77.6245` | Resolves the delivery store; everything is priced for it |
| Search keyword | `milk`, `chocolate`, `atta` | Searches the keyword in each location, paginated |
| Category URL | `https://www.zepto.com/Categories?categoryId={X}&subCategoryId={Y}` | Sweeps a category for each location (use this deeplink form — it carries both ids the API needs) |
| Product URL | `https://www.zepto.com/pn/{slug}/pvid/{id}` | Looks up that product (resolved via search) for each location |

**Not supported:** placing orders, cart / checkout, account-only data, or any non-public content. The actor reads only the public catalogue.

#### ⚙️ How it works

1. **Resolve** each location — free text is geocoded through Zepto's own maps, then matched to a serviceable store.
2. **Fetch** the catalogue from Zepto's app API: keyword search, category page, or product page — paginated.
3. **Parse** the product grid into flat rows; prices are converted from paise to ₹.
4. **Tag** every row with its store / location, dedupe, and emit one row per product.

#### ⚙️ Input parameters

| Field | Type | Default | Description |
|---|---|---|---|
| `locations` | array | — | Area names or `lat,lng` pairs. **Required** (Zepto prices are per-store). |
| `searchQueries` | array | — | Keywords to search in each location. |
| `startUrls` | array | — | Zepto category (`/cn/…/cid/…`) and/or product (`/pn/…/pvid/…`) URLs. |
| `maxItems` | integer | `1000` | Hard cap on product rows for the whole run. |
| `maxItemsPerQuery` | integer | `1000` | Cap per keyword × location (and per URL × location). |
| `maxConcurrency` | integer | `4` | Parallel requests. Keep low — Zepto rate-limits per IP. |
| `maxRequestRetries` | integer | `12` | Retry budget on Zepto's rate-limit codes (the 477–486 band) and network errors. Each retry rotates to a fresh India IP across two residential pools. |
| `proxy` | object | Apify Residential IN | India residential is used automatically. |

#### 📊 Output overview

Each dataset record is **one product, priced for one location**. Run the same keyword across several `locations` to get one row per (product × location) — ideal for cross-city price comparison. All money fields are in INR (₹), converted from Zepto's internal paise.

#### 📦 Output sample

```json
{
  "rowType": "product",
  "productId": "5dac97a5-0241-4b24-9a5d-8243838257f5",
  "variantId": "ba77f9b3-0525-4ce8-bc4b-a2480419b780",
  "productUrl": "https://www.zepto.com/pn/godrej-jersey-toned-fresh-milk-pouch/pvid/ba77f9b3-0525-4ce8-bc4b-a2480419b780",
  "name": "Godrej Jersey Toned Fresh Milk | Pouch",
  "brand": "Godrej Jersey",
  "mrp": 27,
  "sellingPrice": 26,
  "discountedPrice": 26,
  "discountPercent": 3,
  "zeptoPassPrice": null,
  "packSize": "1 pack (490 ml or 500 ml)",
  "unit": "ml",
  "weightInGms": 500,
  "images": ["https://cdn.zeptonow.com/production/cms/product_variant/8fd1fa19-56f7-4f23-8a0d-625fc669cec2.jpeg"],
  "inStock": true,
  "availableQuantity": 10,
  "category": "Dairy, Bread & Eggs",
  "categoryId": "5d92e29c-1f5a-43a2-9d8e-8b6f5f0f0a11",
  "rating": 4.6,
  "ratingCount": 66206,
  "storeId": "5ec071fd-78df-41f6-b3ae-7298d9f96a3d",
  "location": "Koramangala, Bengaluru",
  "latitude": 12.9352,
  "longitude": 77.6245,
  "sourceQuery": "milk",
  "sourceUrl": null,
  "scrapedAt": "2026-06-23T20:30:00.000Z"
}
````

#### 🗂 Key output fields

| Field | Type | Notes |
|---|---|---|
| `name` / `brand` | string | Product name + brand |
| `sellingPrice` / `mrp` / `discountedPrice` | number | In ₹ (converted from paise) |
| `discountPercent` | number | Discount off MRP |
| `zeptoPassPrice` | number | null | Zepto Pass member price, when offered |
| `packSize` / `unit` / `weightInGms` | string / number | Pack details |
| `inStock` / `availableQuantity` | boolean / number | Live stock for the store |
| `rating` / `ratingCount` | number | Product rating + number of ratings |
| `category` / `categoryId` | string | Primary category |
| `images` | string\[] | Product image URLs |
| `productUrl` / `productId` / `variantId` | string | Canonical URL + ids |
| `storeId` / `location` / `latitude` / `longitude` | string / number | The store & location this row was priced for |
| `sourceQuery` / `sourceUrl` | string | null | What produced the row |

#### ❓ FAQ

**Why do I need a location?** Zepto is a delivery app — every product's price, discount and stock depend on the store serving your address. No location, no catalogue.

**Can I compare prices across cities?** Yes — that's the point. Put several entries in `locations` and the same product comes back once per location, each with its local price and stock.

**How many products per keyword?** A Zepto keyword search returns roughly a few hundred products. Categories can be larger. Use `maxItemsPerQuery` to cap.

**Are the prices accurate / live?** Yes — they're read live from Zepto's catalogue at scrape time, in ₹.

**Do I need to set up proxies?** No. India residential routing is built in (Zepto is India-only). Just give it a location and what to scrape.

#### 💬 Support

Found a bug or need an extra field? Open an issue on the [actor's Issues tab](https://apify.com/memo23/zepto-product-scraper/issues) and it'll be looked at quickly.

#### 🛠 Additional services

Need a custom field, another quick-commerce app (Blinkit, Instamart), or a scheduled price-tracking feed into your warehouse? Custom scraping and pipeline work is available on request.

#### 🔎 Explore more scrapers

Looking for more India / commerce data sources? Check out the other directory, e-commerce and company scrapers in the same publisher's collection on the Apify Store.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Zepto (Kiranakart Technologies Pvt. Ltd.) or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available Zepto product catalogue data — no authenticated endpoints, no account-only features, no order placement. Users are responsible for ensuring their use complies with Zepto's Terms of Service, applicable data-protection law (including India's DPDP Act, GDPR and CCPA where relevant) and any contractual obligations of their own organisation.

***

### SEO Keywords

zepto scraper, scrape zepto, zepto product scraper, zepto price scraper, zepto api, zepto data extraction, quick commerce scraper india, zepto price tracker, grocery price scraper india, zepto product data, q-commerce price monitoring, zepto competitor analysis, indian grocery delivery scraper, zepto category scraper, zepto mrp discount scraper, blinkit instamart zepto data, dynamic pricing grocery india, zepto stock availability, scrape indian quick commerce, zepto bengaluru mumbai delhi prices

# Actor input Schema

## `locations` (type: `array`):

An area / landmark name (e.g. `Koramangala, Bengaluru`, `Bandra West, Mumbai`) or a `latitude,longitude` pair (e.g. `12.9352,77.6245`). Text is geocoded via Zepto's own maps. Must be inside a Zepto-serviceable city.

## `searchQueries` (type: `array`):

Keywords to search, e.g. `milk`, `chocolate`, `atta`. Each is searched in each location and paginated.

## `startUrls` (type: `array`):

Product URLs `https://www.zepto.com/pn/{slug}/pvid/{id}` and/or category URLs in the app deeplink form `https://www.zepto.com/Categories?categoryId={X}&subCategoryId={Y}` (this form carries both ids the category API needs — a plain `/cn/.../cid/{id}` URL has only one and won't list products). Each is scraped for each location.

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

Hard cap on product rows across the entire run. Each row is one paid `product` event. Default 1000. Free-tier users are additionally capped at 100.

## `maxItemsPerQuery` (type: `integer`):

Cap per (keyword × location) and per (URL × location). Note Zepto search returns roughly a few hundred products per keyword. Default 1000.

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

Parallel HTTP requests. Zepto rate-limits per IP — keep this low (3–5) so the limiter isn't tripped. Default 4.

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

Per-request retry budget on Zepto's rate-limit codes (the 477–486 band), 429 and network errors. Each retry rotates to a fresh India residential IP across two pools (Evomi + Webshare) with backoff, so throttled requests break through. Default 12.

## `proxy` (type: `object`):

Zepto is India-only and rate-reactive. The actor routes through India residential proxies automatically; this setting is kept for compatibility.

## Actor input object example

```json
{
  "locations": [
    "Koramangala, Bengaluru"
  ],
  "searchQueries": [
    "milk"
  ],
  "startUrls": [],
  "maxItems": 1000,
  "maxItemsPerQuery": 1000,
  "maxConcurrency": 4,
  "maxRequestRetries": 12,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# 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 = {
    "locations": [
        "Koramangala, Bengaluru"
    ],
    "searchQueries": [
        "milk"
    ],
    "startUrls": [],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/zepto-product-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 = {
    "locations": ["Koramangala, Bengaluru"],
    "searchQueries": ["milk"],
    "startUrls": [],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/zepto-product-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 '{
  "locations": [
    "Koramangala, Bengaluru"
  ],
  "searchQueries": [
    "milk"
  ],
  "startUrls": [],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call memo23/zepto-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zepto Product Scraper - Prices, MRP, Stock by Location",
        "description": "Scrape Zepto product listings for any delivery location in India — name, brand, price, MRP, discount, pack size, stock, rating and image. Search by keyword or paste category/product URLs. Compare prices across cities. JSON, CSV or Excel out, billed per product.",
        "version": "0.1",
        "x-build-id": "j4CtzOESrgFtFYkCi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~zepto-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-zepto-product-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/memo23~zepto-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-zepto-product-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/memo23~zepto-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-zepto-product-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "locations": {
                        "title": "Delivery locations",
                        "type": "array",
                        "description": "An area / landmark name (e.g. `Koramangala, Bengaluru`, `Bandra West, Mumbai`) or a `latitude,longitude` pair (e.g. `12.9352,77.6245`). Text is geocoded via Zepto's own maps. Must be inside a Zepto-serviceable city.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search, e.g. `milk`, `chocolate`, `atta`. Each is searched in each location and paginated.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Category / product URLs",
                        "type": "array",
                        "description": "Product URLs `https://www.zepto.com/pn/{slug}/pvid/{id}` and/or category URLs in the app deeplink form `https://www.zepto.com/Categories?categoryId={X}&subCategoryId={Y}` (this form carries both ids the category API needs — a plain `/cn/.../cid/{id}` URL has only one and won't list products). Each is scraped for each location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max products (whole run)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on product rows across the entire run. Each row is one paid `product` event. Default 1000. Free-tier users are additionally capped at 100.",
                        "default": 1000
                    },
                    "maxItemsPerQuery": {
                        "title": "Max products per query × location",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap per (keyword × location) and per (URL × location). Note Zepto search returns roughly a few hundred products per keyword. Default 1000.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max parallel requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel HTTP requests. Zepto rate-limits per IP — keep this low (3–5) so the limiter isn't tripped. Default 4.",
                        "default": 4
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Per-request retry budget on Zepto's rate-limit codes (the 477–486 band), 429 and network errors. Each retry rotates to a fresh India residential IP across two pools (Evomi + Webshare) with backoff, so throttled requests break through. Default 12.",
                        "default": 12
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Zepto is India-only and rate-reactive. The actor routes through India residential proxies automatically; this setting is kept for compatibility.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
