# Yaga Marketplace Data Scraper (`thescrapelab/yaga-marketplace-scraper`) Actor

Yaga scraper for product listings, prices, images, seller profiles, ratings, likes, and inventory data from Yaga search, item, and shop pages.

- **URL**: https://apify.com/thescrapelab/yaga-marketplace-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** E-commerce, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Yaga Marketplace Scraper

Yaga Marketplace Scraper extracts public Yaga South Africa listings and seller profile data for marketplace research, price monitoring, inventory tracking, and lead enrichment.

Use it to collect structured Yaga product listings, prices, images, categories, brands, sizes, seller profile URLs, public rating aggregates, likes, and shop inventory from keyword searches, direct item URLs, and public seller profiles.

### Main Use Cases

- Monitor public Yaga listings for brands, categories, sizes, and prices.
- Track competitor and seller inventory on Yaga South Africa.
- Build pricing research, trend analysis, and availability dashboards.
- Enrich public marketplace seller leads with profile and shop metadata.
- Run recurring checks for new public listings matching a keyword or seller profile.

### What Data It Extracts

Listing rows can include:

- `recordType`
- `url`
- `listingId`
- `title`
- `description`
- `price`
- `currency`
- `originalPrice`
- `discount`
- `condition`
- `brand`
- `size`
- `color`
- `category`
- `subcategory`
- `sellerName`
- `sellerUrl`
- `location`
- `imageUrls`
- `mainImageUrl`
- `isSold`
- `isReserved`
- `likesCount`
- `viewCount`
- `postedAt`
- `updatedAt`
- `scrapedAt`
- `sourcePageUrl`

Profile rows can include:

- `recordType`
- `url`
- `profileId`
- `profileSlug`
- `sellerName`
- `sellerUrl`
- `description`
- `profileImageUrl`
- `location`
- `province`
- `isActive`
- `isInfluencerShop`
- `completedOrdersCount`
- `feedbackTotal`
- `avgRating`
- `likesCount`
- `scrapedAt`
- `sourcePageUrl`

Each dataset row includes `recordType`, so you can filter listings and profiles separately.

### Input Configuration

You can run a search, scrape known item URLs, scrape public seller profiles, or combine these inputs.

| Field | Type | Description |
| --- | --- | --- |
| `searchQuery` | String | Keyword to search on Yaga, such as `nike sneakers`, `dress`, or `jacket`. |
| `itemUrls` | URL list | Direct Yaga item/listing URLs. Use this when you already know the product pages. |
| `profiles` | String list | Public Yaga profile handles, slugs, or full profile URLs. |
| `maxListings` | Integer | Maximum listing rows to save from search and profile pages. Default: `20`. Maximum: `500`. |
| `continuationToken` | String | Continue a search from a previous run. Use the `nextContinuationToken` returned by the Actor with the same `searchQuery`. |
| `includeSoldItems` | Boolean | Save sold or unavailable listings. Default: `false`. |

#### Example Input

```json
{
  "searchQuery": "nike sneakers",
  "profiles": ["megano-5"],
  "maxListings": 20,
  "includeSoldItems": false
}
````

#### Continue A Search

When a search run reaches `maxListings`, the Actor can return `nextContinuationToken` in the run output. Use it with the same `searchQuery` to scrape the next batch at the same per-result price.

First run:

```json
{
  "searchQuery": "dress",
  "maxListings": 100
}
```

Next run:

```json
{
  "searchQuery": "dress",
  "maxListings": 100,
  "continuationToken": "100"
}
```

#### Direct Item URL Example

```json
{
  "itemUrls": [
    { "url": "https://www.yaga.co.za/example-shop/product/example-item" }
  ],
  "maxListings": 1
}
```

### Example Output

```json
{
  "recordType": "listing",
  "url": "https://www.yaga.co.za/example-shop/product/example-item",
  "listingId": "example-item",
  "title": "Nike sneakers",
  "description": "Used Nike sneakers in good condition",
  "price": 450,
  "currency": "ZAR",
  "condition": "Used",
  "brand": "Nike",
  "size": "UK 6",
  "category": "Women",
  "subcategory": "Shoes > Sneakers",
  "sellerName": "Example seller",
  "sellerUrl": "https://www.yaga.co.za/example-shop",
  "location": "Western Cape",
  "mainImageUrl": "https://images.yaga.co.za/example/image.jpeg",
  "isSold": false,
  "isReserved": false,
  "likesCount": 12,
  "scrapedAt": "2026-06-09T12:00:00.000Z",
  "sourcePageUrl": "https://www.yaga.co.za/search/nike%20sneakers"
}
```

```json
{
  "recordType": "profile",
  "url": "https://www.yaga.co.za/example-shop",
  "profileSlug": "example-shop",
  "sellerName": "Example seller",
  "sellerUrl": "https://www.yaga.co.za/example-shop",
  "description": "Public shop description",
  "location": "Cape Town",
  "province": "Western Cape",
  "completedOrdersCount": "260+",
  "feedbackTotal": 159,
  "avgRating": 4.8,
  "likesCount": 346,
  "scrapedAt": "2026-06-09T12:00:00.000Z",
  "sourcePageUrl": "https://www.yaga.co.za/example-shop"
}
```

### How To Run On Apify

1. Open the Actor in Apify Console.
2. Enter a Yaga search query, item URLs, profile handles, profile URLs, or a combination.
3. Set `maxListings` to the number of listing rows you need.
4. Start the Actor.
5. Open the Dataset tab to preview, filter, or download results.

### Exporting Results

Results are saved continuously to the default Apify dataset while the Actor runs. You can export them as JSON, CSV, Excel, XML, RSS, or HTML from the Dataset tab, or access them through the Apify API.

Python API example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchQuery": "nike sneakers",
    "maxListings": 20,
    "profiles": ["megano-5"],
}

run = client.actor("thescrapelab/yaga-marketplace-scraper").call(run_input=run_input)
dataset_id = run["defaultDatasetId"]
items = client.dataset(dataset_id).list_items().items

for item in items:
    print(item)
```

### Recommended Run Settings

The measured default is `512 MB` memory. Search and profile discovery use browser rendering, and 256 MB was not reliable for browser search runs. Direct item URL runs are lighter, but 512 MB still measured cheaper than 256 MB because the lower-memory run took longer.

| Run size | Memory | Timeout | Notes |
| --- | ---: | ---: | --- |
| Direct item URL | 512 MB | 3 minutes | Best for known product URLs. |
| Small search, up to 5 listings | 512 MB | 5 minutes | Good for tests and quick checks. |
| Medium search, around 20 listings | 512 MB | 10 minutes | Recommended default client workload. |
| Large capped run, up to 60-100 listings | 512 MB | 10-15 minutes | Keep `maxListings` capped for predictable cost. |
| Larger search batches, up to 500 listings | 512-1024 MB | 15-30 minutes | Use `continuationToken` for repeatable batches. Test before scheduling. |
| Search plus profiles | 512 MB | 10 minutes | Uses rendered discovery pages plus item fetching. |

Avoid increasing memory unless your own measurements show lower total cost or fewer failures. In tests, 1024 MB cost more for small search runs.

### Limits And Caveats

- This Actor collects public Yaga pages only. It does not log in or collect private account data.
- The Actor does not bypass paywalls, CAPTCHA, or access controls.
- `maxListings` limits listing rows, not profile summary rows.
- Search runs can continue with `nextContinuationToken` when another batch may be available.
- Sold or unavailable listings are skipped by default to reduce low-value results.
- Some fields may be missing when they are not shown publicly or when Yaga changes page structure.
- Search coverage depends on what Yaga returns on the rendered public search/profile page during the run.
- Keep recurring runs reasonable and review Yaga's current terms before high-volume use.

### Troubleshooting

| Problem | What to check |
| --- | --- |
| No results | Try a broader `searchQuery`, a direct item URL, or an exact public profile handle. |
| Fewer results than expected | Increase `maxListings` up to `500`, or use `nextContinuationToken` to continue in another run. |
| Missing fields | Confirm the field is visible on the public Yaga page. Not every listing exposes every field. |
| Profile not found | Use the exact profile slug or full profile URL instead of a display name. |
| Run takes too long | Lower `maxListings` or continue in smaller batches with `nextContinuationToken`. |
| Possible blocking or rate limits | Retry later with a smaller `maxListings` value. |

### Pricing

This Actor is best suited to per-result pricing because each saved dataset row is the client-visible value. Keep `maxListings` low for test runs and raise it only when you need broader coverage.

Recommended monetization is pay per event using the default dataset item event as the primary charge. A small Actor-start event can cover tiny failed or empty runs, but result pricing should remain simple and transparent.

Continuation does not require a different pricing model. Each batch still charges the same dataset-item event per saved result.

### FAQ

#### Can I scrape Yaga search results?

Yes. Provide `searchQuery` and set `maxListings` to the number of listing rows you want.

#### Can I scrape more than one batch?

Yes. Use `nextContinuationToken` from the previous run with the same `searchQuery`, or raise `maxListings` up to `500` for a larger single run.

#### Can I scrape a Yaga seller profile?

Yes. Add public handles, slugs, or full profile URLs to `profiles`.

#### Can I scrape exact Yaga item URLs?

Yes. Add direct item URLs to `itemUrls`.

#### Does it scrape sold listings?

Sold and unavailable listings are skipped by default. Set `includeSoldItems` to `true` if you need them.

#### Does it use a proxy?

The default configuration does not require a proxy in normal tests. If future runs show blocking symptoms, tune delay and proxy/session settings carefully and measure cost again.

#### What keywords can I use?

Common Yaga research queries include `nike sneakers`, `adidas shoes`, `dress`, `jacket`, `zara`, `handbag`, `vintage`, `kids clothes`, `woolworths`, and `cotton on`.

### Support

For best reliability, use exact item URLs or exact public profile handles/URLs. If a run returns fewer fields than expected, compare the dataset row with the public Yaga page and check whether the missing field is visible there.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to search for on Yaga, such as "nike sneakers", "dress", or "jacket".

## `itemUrls` (type: `array`):

Optional direct Yaga item/listing URLs to scrape. Use this when you already have specific product URLs.

## `profiles` (type: `array`):

Optional public Yaga profile names, handles, or URLs to scrape profile details and the user's listed items. Examples: "megano-5", "@megano-5", "https://www.yaga.co.za/megano-5". Display names with spaces are converted to a likely slug and only work when they match the public profile URL.

## `maxListings` (type: `integer`):

Maximum number of listing records to save from search and profile pages. Direct item URL runs process the provided URLs unless this limit is set lower.

## `continuationToken` (type: `string`):

Optional token from a previous search run. Use it with the same search query to continue from the next batch of listings.

## `includeSoldItems` (type: `boolean`):

Save listings that appear sold or unavailable. Leave off to skip sold items and spend results only on currently useful listings.

## Actor input object example

```json
{
  "searchQuery": "nike sneakers",
  "itemUrls": [],
  "profiles": [
    "megano-5"
  ],
  "maxListings": 20,
  "includeSoldItems": false
}
```

# Actor output Schema

## `results` (type: `string`):

All public Yaga listing and profile records saved by this Actor.

## `nextContinuationToken` (type: `string`):

Use this token with the same search query to continue scraping the next batch, when available.

# 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 = {
    "searchQuery": "nike sneakers",
    "itemUrls": [],
    "profiles": [
        "megano-5"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/yaga-marketplace-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 = {
    "searchQuery": "nike sneakers",
    "itemUrls": [],
    "profiles": ["megano-5"],
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/yaga-marketplace-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 '{
  "searchQuery": "nike sneakers",
  "itemUrls": [],
  "profiles": [
    "megano-5"
  ]
}' |
apify call thescrapelab/yaga-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yaga Marketplace Data Scraper",
        "description": "Yaga scraper for product listings, prices, images, seller profiles, ratings, likes, and inventory data from Yaga search, item, and shop pages.",
        "version": "0.1",
        "x-build-id": "1TFcaDYb6cSnbFaui"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/thescrapelab~yaga-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-thescrapelab-yaga-marketplace-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/thescrapelab~yaga-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-thescrapelab-yaga-marketplace-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/thescrapelab~yaga-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-thescrapelab-yaga-marketplace-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": {
                    "searchQuery": {
                        "title": "Search",
                        "type": "string",
                        "description": "Keyword to search for on Yaga, such as \"nike sneakers\", \"dress\", or \"jacket\"."
                    },
                    "itemUrls": {
                        "title": "Item URLs",
                        "type": "array",
                        "description": "Optional direct Yaga item/listing URLs to scrape. Use this when you already have specific product URLs.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "profiles": {
                        "title": "Profiles",
                        "type": "array",
                        "description": "Optional public Yaga profile names, handles, or URLs to scrape profile details and the user's listed items. Examples: \"megano-5\", \"@megano-5\", \"https://www.yaga.co.za/megano-5\". Display names with spaces are converted to a likely slug and only work when they match the public profile URL.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of listing records to save from search and profile pages. Direct item URL runs process the provided URLs unless this limit is set lower.",
                        "default": 20
                    },
                    "continuationToken": {
                        "title": "Continuation token",
                        "type": "string",
                        "description": "Optional token from a previous search run. Use it with the same search query to continue from the next batch of listings."
                    },
                    "includeSoldItems": {
                        "title": "Include sold items",
                        "type": "boolean",
                        "description": "Save listings that appear sold or unavailable. Leave off to skip sold items and spend results only on currently useful listings.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```