# Miro Marketplace Scraper (`automation-lab/miro-marketplace-scraper`) Actor

Extract Miro Marketplace apps, vendors, categories, pricing labels, screenshots, support links, and compliance URLs from public pages.

- **URL**: https://apify.com/automation-lab/miro-marketplace-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Miro Marketplace Scraper

Extract public Miro Marketplace apps, vendors, categories, pricing labels, screenshots, support links, and compliance URLs from Miro's app ecosystem.

### What does Miro Marketplace Scraper do?

Miro Marketplace Scraper turns the public Miro Marketplace into a clean dataset.
It reads the public marketplace page, parses the embedded Next.js app catalog, and saves one row per app.
Use it to monitor Miro integrations, find partner leads, compare app categories, or build a repeatable ecosystem database.

### Who is it for?

- 🧩 SaaS partnership teams tracking tools that integrate with Miro.
- 📊 Competitive intelligence teams watching collaboration and whiteboard ecosystems.
- 🧑‍💻 Developer relations teams looking for app vendors and integration partners.
- 🧾 Procurement and security teams collecting support, privacy, and terms links.
- 🏢 Agencies building reports about collaboration software marketplaces.

### Why use this actor?

- HTTP-only extraction: no browser overhead for the default Miro Marketplace page.
- Public data only: no login, cookies, or private API keys required.
- Rich app metadata: app, vendor, categories, pricing labels, media, and compliance links.
- Repeatable exports: run daily or weekly to detect new apps and category changes.
- API-ready output: use Apify datasets, webhooks, integrations, or MCP workflows.

### What data can I extract from Miro Marketplace?

| Field | Description |
| --- | --- |
| `appName` | Marketplace app name |
| `appUrl` | Public Miro Marketplace app URL |
| `vendorName` | Developer or vendor name |
| `vendorUrl` | Vendor website when present |
| `tagline` | Short marketplace description |
| `description` | Longer HTML-stripped app description when requested |
| `categories` | Human-readable marketplace categories |
| `categoryKeys` | Stable category keys useful for filtering |
| `pricing` | Miro pricing label such as Free or Free and paid |
| `isFree` | Boolean interpretation of the pricing label when known |
| `iconUrl` | App icon URL |
| `screenshots` | Screenshot, GIF, or video URLs |
| `supportUrl` | Support URL or email when present |
| `privacyPolicyUrl` | Privacy policy URL when present |
| `termsOfServiceUrl` | Terms URL when present |
| `marketplaceRank` | Position in the source payload |
| `sourceUrl` | Miro page that produced the record |
| `scrapedAt` | ISO timestamp for the extraction |

### How much does it cost to scrape Miro Marketplace apps?

This actor uses pay-per-event pricing.
There is a small start charge and a per-item charge for each saved app record.
The exact live prices are shown on the Apify Store pricing panel.
Use `maxItems` for tight cost control during testing.
A typical default run can extract 100 app records from one HTTP request.

### Quick start

1. Open the actor on Apify.
2. Keep the default `https://miro.com/marketplace/` start URL.
3. Set `maxItems` to the number of apps you need.
4. Optionally add `searchTerm` or `categoryKeys` filters.
5. Click **Start**.
6. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Input options

#### `startUrls`

Miro Marketplace pages to scrape.
The default marketplace URL currently exposes hundreds of public app records in its initial payload.

#### `maxItems`

Maximum number of app rows to save.
Use a low value for tests and a higher value for full exports.

#### `searchTerm`

Optional local text filter.
It checks app name, vendor name, short description, full description, and category captions.

#### `categoryKeys`

Optional exact category-key filter.
Examples include `free`, `free-and-paid`, `built-by-miro`, `strategy-planning-apps`, and `projects-tasks`.

#### `includeFullDescription`

When enabled, the actor includes longer app descriptions stripped of HTML markup.
Disable it for lighter exports.

#### `delayMs`

Polite delay between multiple start URLs.
For the default single URL, this has almost no runtime impact.

### Example input: full marketplace sample

```json
{
  "startUrls": [{ "url": "https://miro.com/marketplace/" }],
  "maxItems": 100,
  "includeFullDescription": true,
  "delayMs": 500
}
````

### Example input: planning apps

```json
{
  "startUrls": [{ "url": "https://miro.com/marketplace/" }],
  "maxItems": 50,
  "searchTerm": "planning",
  "includeFullDescription": true
}
```

### Example input: built by Miro

```json
{
  "startUrls": [{ "url": "https://miro.com/marketplace/" }],
  "maxItems": 100,
  "categoryKeys": ["built-by-miro"],
  "includeFullDescription": false
}
```

### Example output

```json
{
  "appName": "Jira Cards",
  "appUrl": "https://miro.com/marketplace/jira/",
  "vendorName": "Miro",
  "tagline": "Visualize, edit, or create Jira tasks directly in Miro",
  "categories": ["Projects & tasks", "Strategy & planning", "Agile workflows"],
  "pricing": "Free with Miro plans",
  "isFree": true,
  "marketplaceRank": 1,
  "sourceUrl": "https://miro.com/marketplace/"
}
```

### Tips for best results

- Start with `maxItems: 25` if you are exploring the output shape.
- Use `searchTerm` for quick keyword lists such as agile, diagram, Jira, or AI.
- Use `categoryKeys` when you need a stable repeatable filter.
- Keep `includeFullDescription` enabled for lead research and disabled for light monitoring.
- Schedule runs weekly if you want to spot new integrations.

### Integrations

- Send new app rows to Google Sheets for ecosystem tracking.
- Trigger a webhook when a scheduled run finishes.
- Feed vendor URLs into enrichment or contact-finder actors.
- Store historical datasets and compare category changes over time.
- Export records to BI tools for marketplace trend dashboards.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/miro-marketplace-scraper').call({
  startUrls: [{ url: 'https://miro.com/marketplace/' }],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/miro-marketplace-scraper').call(run_input={
    'startUrls': [{'url': 'https://miro.com/marketplace/'}],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~miro-marketplace-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://miro.com/marketplace/"}],"maxItems":100}'
```

### MCP usage

Use Apify MCP to call this actor from Claude Desktop, Claude Code, or other MCP clients.

Add the Apify MCP server in Claude Code:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/miro-marketplace-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/miro-marketplace-scraper"
    }
  }
}
```

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/miro-marketplace-scraper
```

Example prompts:

- "Run the Miro Marketplace Scraper for built-by-miro apps and summarize vendors."
- "Export the first 100 Miro Marketplace apps and group them by pricing label."
- "Find Miro apps related to planning and return vendor websites."

### Monitoring new Miro apps

Schedule the actor to run on a cadence.
Keep the same input each time.
Compare new datasets by `appId`, `appKey`, or `appUrl`.
This gives you a practical Miro app marketplace monitor without building custom infrastructure.

### Lead generation workflow

1. Run the actor with a category or keyword filter.
2. Export `vendorName`, `vendorUrl`, `supportUrl`, and compliance URLs.
3. Deduplicate vendors in your CRM or spreadsheet.
4. Enrich vendor websites with contact or company data.
5. Prioritize vendors by category and marketplace rank.

### Competitive intelligence workflow

1. Run a full marketplace export monthly.
2. Track app counts by category.
3. Watch pricing labels for free, paid, and Miro-plan apps.
4. Identify vendors appearing in strategic categories.
5. Compare new rows against your historical dataset.

### FAQ

#### Why did I get fewer apps than expected?

Check `maxItems`, `searchTerm`, and `categoryKeys`.
Filters are applied after the marketplace payload is parsed.
A narrow keyword or category can intentionally return fewer records.

#### Why are rating or review fields missing?

The observed public Miro Marketplace payload does not expose reliable rating or review counts.
The actor avoids null-only fields and focuses on the metadata available in the public payload.

#### Do I need proxies?

No proxy is required for the default public marketplace page.
The actor is HTTP-only and uses polite headers and delays.

### Legality and ethical use

This actor extracts publicly available Miro Marketplace metadata.
Do not use it to collect private user data, bypass access controls, or overload the target site.
Review Miro's terms and your local regulations before using scraped data in production workflows.

### Related scrapers

Automation Lab publishes actors for marketplace, SaaS, lead, and web data workflows.
Use related marketplace scrapers when you need other ecosystems such as Slack, HubSpot, Zoom, or app-store style directories.
Keep each actor focused on the source website for cleaner schemas and easier monitoring.

### Changelog

- `0.1` Initial HTTP implementation for public Miro Marketplace app metadata.

### Support

If a run fails or the output looks wrong, open an Apify issue with your run URL and input.
Include the expected category, search term, and approximate record count so the problem can be reproduced quickly.

# Actor input Schema

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

Miro Marketplace pages to scrape. The default marketplace page contains hundreds of public app records in the initial Next.js payload.

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

Maximum number of Miro Marketplace app records to save.

## `searchTerm` (type: `string`):

Optional case-insensitive filter applied to app name, vendor, description, and category labels.

## `categoryKeys` (type: `array`):

Optional Miro category keys to keep, such as free, strategy-planning-apps, projects-tasks, agile-workflow-apps, or built-by-miro.

## `includeFullDescription` (type: `boolean`):

Include longer HTML-stripped marketplace descriptions when available. Disable for a lighter lead list.

## `delayMs` (type: `integer`):

Polite delay between start URLs. The default is conservative and cheap for HTTP-only scraping.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://miro.com/marketplace/"
    }
  ],
  "maxItems": 20,
  "searchTerm": "planning",
  "categoryKeys": [],
  "includeFullDescription": true,
  "delayMs": 500
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://miro.com/marketplace/"
        }
    ],
    "maxItems": 20,
    "searchTerm": "planning",
    "categoryKeys": [],
    "includeFullDescription": true,
    "delayMs": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/miro-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 = {
    "startUrls": [{ "url": "https://miro.com/marketplace/" }],
    "maxItems": 20,
    "searchTerm": "planning",
    "categoryKeys": [],
    "includeFullDescription": True,
    "delayMs": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/miro-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 '{
  "startUrls": [
    {
      "url": "https://miro.com/marketplace/"
    }
  ],
  "maxItems": 20,
  "searchTerm": "planning",
  "categoryKeys": [],
  "includeFullDescription": true,
  "delayMs": 500
}' |
apify call automation-lab/miro-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Miro Marketplace Scraper",
        "description": "Extract Miro Marketplace apps, vendors, categories, pricing labels, screenshots, support links, and compliance URLs from public pages.",
        "version": "0.1",
        "x-build-id": "KLbCcgIKUvFbfoi43"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~miro-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-miro-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/automation-lab~miro-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-miro-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/automation-lab~miro-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-miro-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Miro Marketplace pages to scrape. The default marketplace page contains hundreds of public app records in the initial Next.js payload.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Miro Marketplace app records to save.",
                        "default": 20
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Optional case-insensitive filter applied to app name, vendor, description, and category labels."
                    },
                    "categoryKeys": {
                        "title": "Category keys",
                        "type": "array",
                        "description": "Optional Miro category keys to keep, such as free, strategy-planning-apps, projects-tasks, agile-workflow-apps, or built-by-miro.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeFullDescription": {
                        "title": "Include full descriptions",
                        "type": "boolean",
                        "description": "Include longer HTML-stripped marketplace descriptions when available. Disable for a lighter lead list.",
                        "default": true
                    },
                    "delayMs": {
                        "title": "Delay between pages (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between start URLs. The default is conservative and cheap for HTTP-only scraping.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
