# Monday.com Apps Marketplace Scraper (`automation-lab/monday-apps-marketplace-scraper`) Actor

Extract monday.com Marketplace app listings for competitor tracking, partner discovery, category research, and SaaS lead workflows.

- **URL**: https://apify.com/automation-lab/monday-apps-marketplace-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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

## Monday.com Apps Marketplace Scraper

Scrape public monday.com Marketplace app listings for competitor tracking, partner research, category monitoring, and SaaS marketplace intelligence.

The actor discovers listing pages from monday.com's public marketplace sitemap, visits each public listing page with fast HTTP requests, and outputs clean app records with names, IDs, URLs, descriptions, keywords, images, and timestamps.

### What does Monday.com Apps Marketplace Scraper do?

It extracts structured data from public monday.com Marketplace listing pages.

Use it to build a spreadsheet, dataset, or automation flow containing monday app marketplace records.

The scraper can:

- Discover listing URLs from the official monday.com marketplace sitemap.
- Scrape specific marketplace listing URLs supplied by you.
- Filter apps by keywords such as CRM, Slack, reporting, forms, or integration.
- Save normalized app metadata as typed Apify dataset items.
- Run without a monday.com account.
- Run without a browser for lower cost and faster execution.

### Who is it for?

This actor is useful for SaaS marketplace teams.

It is also useful for monday.com consultants and agencies.

App developers can use it to monitor competing apps.

Partner managers can use it to discover integration opportunities.

Growth teams can use it to find categories, keywords, and positioning patterns.

Researchers can use it to collect a repeatable snapshot of public marketplace listings.

### Why use this actor?

Manual marketplace review is slow.

The public marketplace contains hundreds of app listing URLs.

This actor turns those pages into a dataset you can search, export, join, enrich, and monitor.

It is designed for repeatable workflows rather than one-off browsing.

It uses public HTML metadata and the official sitemap, which makes it less brittle than browser-only scraping.

### What data can you extract?

| Field | Description |
| --- | --- |
| `id` | Numeric monday marketplace listing ID. |
| `name` | App name. |
| `slug` | Listing slug. |
| `url` | Canonical listing URL. |
| `description` | Public listing description from page metadata. |
| `keywords` | Keywords/tags from listing metadata. |
| `imageUrl` | Preview image URL. |
| `title` | Raw page title. |
| `listingType` | App listing or marketplace home page. |
| `source` | Sitemap or input URL. |
| `scrapedAt` | ISO timestamp when the record was scraped. |

### Example output

```json
{
  "id": 23,
  "name": "Miro",
  "slug": "miro",
  "url": "https://monday.com/marketplace/listing/23/miro",
  "description": "Bring visual collaboration to projects with Miro for monday.com",
  "keywords": ["whiteboard", "canvas", "monday", "marketplace"],
  "imageUrl": "https://dapulse-res.cloudinary.com/image/upload/...",
  "title": "Miro - monday.com Marketplace",
  "listingType": "app",
  "source": "sitemap",
  "scrapedAt": "2026-07-03T03:42:39.918Z"
}
````

### How much does it cost to scrape monday.com Marketplace apps?

This actor uses pay-per-event pricing.

The current start event is $0.005 per run.

The BRONZE per-item event is $0.00005418 per saved app listing, with lower per-item rates on higher Apify tiers.

Because the implementation is HTTP-first and does not launch a browser, typical runs are designed to be inexpensive.

Use a low `maxItems` value for a quick test.

Increase `maxItems` when you need a larger marketplace snapshot.

### How to use

1. Open the actor on Apify.
2. Leave `listingUrls` empty to discover apps from the public sitemap.
3. Optionally enter `searchTerms` such as `crm`, `forms`, or `reporting`.
4. Set `maxItems`.
5. Run the actor.
6. Export the dataset to JSON, CSV, Excel, or your integration.

### Input configuration

#### `listingUrls`

Optional monday.com Marketplace listing URLs.

Use this when you want to monitor specific apps.

Leave it empty for sitemap discovery.

#### `searchTerms`

Optional terms used to filter app name, slug, description, title, and keywords.

The filter is case-insensitive.

The actor keeps a record when any term matches.

#### `maxItems`

Maximum number of app records to save.

The default is 100.

#### `maxPagesToScan`

Maximum number of listing pages inspected while applying filters.

Increase this when searching for rare terms.

#### `includeMarketplaceHome`

Set to true to include a summary row for `https://monday.com/marketplace`.

### Output dataset

The default dataset contains one row per scraped app listing.

Each row is designed to be stable for spreadsheets and BI tools.

Array fields such as `keywords` export cleanly in JSON and can be flattened downstream.

### Search and filtering tips

Use broad terms for discovery.

Examples:

- `crm`
- `forms`
- `dashboard`
- `slack`
- `reporting`
- `automation`

For rare terms, increase `maxPagesToScan` so more listing pages are inspected.

For exact app monitoring, use `listingUrls` instead of search.

### Integrations

You can connect the dataset to:

- Google Sheets for marketplace monitoring.
- Airtable for app research databases.
- Zapier or Make for alerting workflows.
- BI tools for category analysis.
- A CRM for partner or lead enrichment.
- A data warehouse for repeat snapshots.

### API usage

#### Node.js

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

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/monday-apps-marketplace-scraper').call(run_input={
    'maxItems': 100,
    'searchTerms': ['crm'],
})
print(run['defaultDatasetId'])
```

#### cURL

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

### MCP usage

Use this actor from Apify MCP tools in Claude Code or Claude Desktop.

MCP URL:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Run the monday.com marketplace scraper for CRM apps and summarize positioning patterns."
- "Export 100 monday marketplace apps and group them by keyword."
- "Monitor these monday app listing URLs weekly and flag description changes."

### Common workflows

#### Competitor monitoring

Provide listing URLs for direct competitors.

Run the actor on a schedule.

Compare names, descriptions, keywords, and images over time.

#### Partner discovery

Run a broad sitemap scrape.

Filter exported records for integration categories and partner keywords.

Add promising apps to your outreach CRM.

#### Category research

Search for a category term.

Export matching records.

Review descriptions and keywords for market positioning.

### Performance notes

The actor uses HTTP requests, not browser automation.

It does not require residential proxies by default.

Large unfiltered runs are still bounded by `maxItems`.

Filtered runs are bounded by `maxPagesToScan`.

### Limitations

Some marketplace UI data is rendered by client-side code and is not present in static HTML.

The MVP focuses on reliable public metadata.

Ratings and review text are not emitted unless monday exposes them in public listing metadata.

If monday changes listing metadata, fields may become temporarily empty until the actor is updated.

### Legality

This actor reads public pages.

Use the data responsibly.

Respect monday.com's terms and applicable laws.

Do not use scraped data for spam or abusive automation.

### FAQ

#### Can I scrape the whole monday.com Marketplace?

Yes. Leave `listingUrls` empty and increase `maxItems` for a larger sitemap-based snapshot.

#### Does this actor require a monday.com login?

No. It uses public marketplace pages and public sitemap URLs.

### Troubleshooting

#### Why did I get zero results?

Your `searchTerms` may be too narrow or `maxPagesToScan` may be too low.

Try removing filters or increasing `maxPagesToScan`.

#### Why are ratings missing?

Ratings are not available in the static listing HTML used by this HTTP-first actor.

The actor avoids unstable internal APIs for reliability and cost control.

#### Why are only 100 records returned?

The default `maxItems` is 100.

Increase it for a larger scrape.

### Related scrapers

Explore other Automation Lab actors for SaaS, marketplace, lead, and competitor research workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/clutch-scraper
- https://apify.com/automation-lab/trustpilot-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

#### 0.1

Initial version with sitemap discovery, listing metadata extraction, keyword filtering, and typed dataset output.

### Support

If a run fails, include the run URL and input when reporting the issue.

For best results, start with a small run and verify the dataset before scheduling large recurring jobs.

# Actor input Schema

## `listingUrls` (type: `array`):

Optional monday.com Marketplace listing URLs. Leave empty to discover apps from https://monday.com/sitemap-apps-mp.xml.

## `searchTerms` (type: `array`):

Optional words or phrases. The scraper keeps apps where any term appears in the app name, slug, description, or keywords.

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

Maximum number of app listing records to save.

## `maxPagesToScan` (type: `integer`):

Upper bound on listing pages inspected while applying filters. Increase this for rare search terms.

## `includeMarketplaceHome` (type: `boolean`):

Save a summary record for https://monday.com/marketplace before app listings.

## Actor input object example

```json
{
  "listingUrls": [
    {
      "url": "https://monday.com/marketplace/listing/23/miro"
    },
    {
      "url": "https://monday.com/marketplace/listing/37/stripe"
    }
  ],
  "searchTerms": [],
  "maxItems": 20,
  "maxPagesToScan": 20,
  "includeMarketplaceHome": false
}
```

# 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 = {
    "listingUrls": [
        {
            "url": "https://monday.com/marketplace/listing/23/miro"
        },
        {
            "url": "https://monday.com/marketplace/listing/37/stripe"
        }
    ],
    "searchTerms": [],
    "maxItems": 20,
    "maxPagesToScan": 20,
    "includeMarketplaceHome": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/monday-apps-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 = {
    "listingUrls": [
        { "url": "https://monday.com/marketplace/listing/23/miro" },
        { "url": "https://monday.com/marketplace/listing/37/stripe" },
    ],
    "searchTerms": [],
    "maxItems": 20,
    "maxPagesToScan": 20,
    "includeMarketplaceHome": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/monday-apps-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 '{
  "listingUrls": [
    {
      "url": "https://monday.com/marketplace/listing/23/miro"
    },
    {
      "url": "https://monday.com/marketplace/listing/37/stripe"
    }
  ],
  "searchTerms": [],
  "maxItems": 20,
  "maxPagesToScan": 20,
  "includeMarketplaceHome": false
}' |
apify call automation-lab/monday-apps-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Monday.com Apps Marketplace Scraper",
        "description": "Extract monday.com Marketplace app listings for competitor tracking, partner discovery, category research, and SaaS lead workflows.",
        "version": "0.1",
        "x-build-id": "7Q9iVLSgTTDmqEGIF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~monday-apps-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-monday-apps-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~monday-apps-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-monday-apps-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~monday-apps-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-monday-apps-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": {
                    "listingUrls": {
                        "title": "Specific listing URLs",
                        "type": "array",
                        "description": "Optional monday.com Marketplace listing URLs. Leave empty to discover apps from https://monday.com/sitemap-apps-mp.xml.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional words or phrases. The scraper keeps apps where any term appears in the app name, slug, description, or keywords.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of app listing records to save.",
                        "default": 20
                    },
                    "maxPagesToScan": {
                        "title": "Maximum pages to scan",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper bound on listing pages inspected while applying filters. Increase this for rare search terms.",
                        "default": 20
                    },
                    "includeMarketplaceHome": {
                        "title": "Include marketplace home page",
                        "type": "boolean",
                        "description": "Save a summary record for https://monday.com/marketplace before app 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
