# Salesforce AppExchange Scraper (`automation-lab/salesforce-appexchange-scraper`) Actor

Extract AppExchange apps, vendors, ratings, categories, pricing, trial signals and listing URLs for Salesforce ecosystem research.

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

## Pricing

from $0.06 / 1,000 appexchange listing saveds

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

## Salesforce AppExchange Scraper

Extract public Salesforce AppExchange apps, vendors, ratings, reviews, categories, pricing signals, trial flags, support links, screenshots, and listing URLs for lead generation and market research.

### What does Salesforce AppExchange Scraper do?

Salesforce AppExchange Scraper turns public AppExchange search results and listing pages into clean structured data.

It can collect:

- App and listing names
- AppExchange listing IDs
- Public listing URLs
- Provider and publisher names
- Provider websites when available
- Marketplace categories and business needs
- App descriptions and long descriptions
- Ratings and review counts
- Pricing plan text
- Free/trial signals
- Supported editions and languages
- Logo and screenshot URLs
- Support links and contact fields when published

### Who is it for?

This scraper is designed for teams that research the Salesforce ecosystem.

Common users include:

- Salesforce consultants building partner/vendor lead lists
- ISVs monitoring adjacent AppExchange products
- RevOps teams enriching CRM account lists
- Partnership teams discovering integration opportunities
- Market researchers tracking categories and vendor positioning
- Agencies comparing ratings and review volume across apps
- Product marketers watching competitor listing copy

### Why use this AppExchange scraper?

AppExchange is a large B2B marketplace, but manually browsing listings is slow.

This actor helps you export repeatable datasets for:

- Vendor discovery
- Competitor monitoring
- Category mapping
- Review-count tracking
- Pricing and trial research
- App ecosystem analysis
- Salesforce partner prospecting

### Data you can extract

| Field | Description |
| --- | --- |
| `listingId` | AppExchange listing ID |
| `appName` | Short app name |
| `title` | Listing title |
| `appUrl` | Public AppExchange detail URL |
| `providerName` | Publisher/provider name |
| `providerWebsite` | Provider website when listed |
| `description` | Short marketplace description |
| `fullDescription` | Detail-page long description |
| `categories` | Marketplace categories and subcategories |
| `businessNeeds` | Business need buckets |
| `editions` | Salesforce editions supported |
| `languages` | Published language codes |
| `pricingPlans` | Public pricing plan text |
| `isFree` | Free signal when detected |
| `hasTrial` | Trial lead flag when detected |
| `rating` | Average listing rating |
| `reviewsCount` | Review count |
| `screenshots` | Public screenshot URLs |
| `supportUrl` | Support URL when published |
| `scrapedAt` | Collection timestamp |

### How much does it cost to scrape Salesforce AppExchange?

This actor uses pay-per-event pricing.

You pay a small run start fee plus a per-listing event for every saved AppExchange record.

The exact platform price is shown on the Apify actor page before you run it.

### Input options

You can start from keyword searches, AppExchange URLs, or category keywords.

#### Search queries

Use `searchQueries` for terms such as:

- `marketing automation`
- `salesforce labs`
- `cpq`
- `data integration`
- `customer service`

#### Start URLs

Use `startUrls` for AppExchange search or detail pages.

Examples:

- `https://appexchange.salesforce.com/appxSearchKeywordResults?keywords=salesforce%20labs`
- `https://appexchange.salesforce.com/appxListingDetail?listingId=a0N3A00000FtRcWUAV`

#### Category keywords

Use `categories` for broad marketplace areas:

- `analytics`
- `integration`
- `marketing`
- `sales`
- `customer service`

### Example input

```json
{
  "searchQueries": ["marketing automation"],
  "maxItems": 50,
  "includeDetails": true
}
````

### Example output

```json
{
  "listingId": "a0N3A00000FtRcWUAV",
  "appName": "ActiveCampaign",
  "title": "ActiveCampaign: Customer Experience Marketing Automation for Salesforce",
  "appUrl": "https://appexchange.salesforce.com/appxListingDetail?listingId=a0N3A00000FtRcWUAV",
  "providerName": "ActiveCampaign",
  "rating": 4.21,
  "reviewsCount": 156,
  "categories": ["marketing", "marketingAutomation"],
  "pricingPlans": ["Default Plan / $149 / monthly / company"],
  "scrapedAt": "2026-06-26T00:00:00.000Z"
}
```

### How to scrape AppExchange search results

1. Open the actor on Apify.
2. Add one or more search queries.
3. Set `maxItems` to the number of listings you need.
4. Keep `includeDetails` enabled for richer records.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### How to scrape specific AppExchange listings

1. Copy listing URLs from AppExchange.
2. Paste them into `startUrls`.
3. Set `maxItems` high enough for your URL list.
4. Run the actor.
5. Use the output for CRM enrichment or competitive monitoring.

### Tips for best results

- Use specific queries for cleaner lead lists.
- Use broad category terms for market maps.
- Enable detail enrichment when you need pricing, editions, languages, and screenshots.
- Disable detail enrichment for faster lightweight search exports.
- Run the same query periodically to monitor rating/review movement.

### Integrations

Export AppExchange data into:

- Salesforce CRM lead/account enrichment workflows
- Google Sheets competitor trackers
- Airtable app directories
- HubSpot partner prospect lists
- Snowflake or BigQuery market datasets
- BI dashboards for ecosystem analysis

### 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/salesforce-appexchange-scraper').call({
  searchQueries: ['salesforce labs'],
  maxItems: 100,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/salesforce-appexchange-scraper').call(run_input={
    'searchQueries': ['data integration'],
    'maxItems': 100,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~salesforce-appexchange-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQueries":["analytics"],"maxItems":50,"includeDetails":true}'
```

### MCP integration

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

MCP endpoint:

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

Add the MCP server in Claude Code:

```bash
claude mcp add apify-salesforce-appexchange "https://mcp.apify.com/?tools=automation-lab/salesforce-appexchange-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

- "Scrape 100 Salesforce AppExchange analytics apps and summarize the top vendors."
- "Find AppExchange apps with high review counts in marketing automation."
- "Create a lead list of Salesforce integration vendors from AppExchange."

### Monitoring workflows

Run the scraper weekly or monthly to monitor:

- New apps in a category
- Rating movement
- Review-count changes
- Listing copy updates
- Trial/pricing changes
- Vendor category expansion

### Lead generation workflows

Use output fields such as provider name, website, support URL, category, rating, and description to build targeted vendor lists.

Example segments:

- High-review Salesforce Labs listings
- Paid marketing automation apps
- Integration apps with trial signals
- Analytics vendors with support links

### Competitive intelligence workflows

Track competitors by listing ID and compare:

- Title and positioning changes
- Description updates
- Rating movement
- Review-count growth
- Pricing-plan text
- Category coverage

### Limitations

The actor only collects public AppExchange data.

It does not log into Salesforce, install apps, access private admin flows, or collect authenticated customer data.

Some fields depend on what a provider publishes on its public listing.

### Legality and ethics

This scraper reads publicly available marketplace pages and public JSON used by AppExchange storefront pages.

You are responsible for using the data lawfully, respecting Salesforce terms, and avoiding abusive workloads.

### Troubleshooting

#### Why are provider contact fields empty?

Not every AppExchange listing publishes website, support email, support phone, or support URL fields. Empty values usually mean the listing does not expose that field publicly.

#### Why do I see fewer records than expected?

Your query may have fewer matching apps, or `maxItems` may be lower than the available result count. Try broader keywords or increase `maxItems`.

### Related scrapers

Other automation-lab actors can complement this workflow:

- CRM enrichment scrapers
- Company directory scrapers
- Marketplace lead scrapers
- Review monitoring scrapers
- B2B vendor discovery scrapers

### FAQ

#### Can it scrape reviews text?

The MVP focuses on listing-level app and vendor records, including rating and review count. Review text may be added later if it remains reliable and public.

#### Does it need proxies?

No proxy is required for the current public API/detail-page approach.

#### Can I scrape exact listing URLs?

Yes. Add `appxListingDetail?listingId=...` URLs to `startUrls`.

#### Can I scrape categories?

Yes. Add category words such as `analytics`, `integration`, `marketing`, or `sales` to `categories`.

#### Is this an official Salesforce tool?

No. This is an independent Apify actor for extracting public AppExchange marketplace information.

# Actor input Schema

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

Keywords to search on AppExchange, such as marketing automation, CPQ, Salesforce Labs, or data integration.

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

Optional AppExchange search URLs or listing detail URLs. Detail URLs must include listingId=... .

## `categories` (type: `array`):

Optional AppExchange category labels/slugs to search, for example marketing, sales, analytics, customer service, or integration.

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

Maximum AppExchange listing records to save.

## `includeDetails` (type: `boolean`):

Open each public listing detail page and parse embedded AppExchange state for pricing plans, editions, languages, screenshots, support, and provider details.

## Actor input object example

```json
{
  "searchQueries": [
    "marketing automation"
  ],
  "startUrls": [
    {
      "url": "https://appexchange.salesforce.com/appxSearchKeywordResults?keywords=salesforce%20labs"
    }
  ],
  "categories": [
    "integration"
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# 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 = {
    "searchQueries": [
        "marketing automation"
    ],
    "startUrls": [
        {
            "url": "https://appexchange.salesforce.com/appxSearchKeywordResults?keywords=salesforce%20labs"
        }
    ],
    "categories": [
        "integration"
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/salesforce-appexchange-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 = {
    "searchQueries": ["marketing automation"],
    "startUrls": [{ "url": "https://appexchange.salesforce.com/appxSearchKeywordResults?keywords=salesforce%20labs" }],
    "categories": ["integration"],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/salesforce-appexchange-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 '{
  "searchQueries": [
    "marketing automation"
  ],
  "startUrls": [
    {
      "url": "https://appexchange.salesforce.com/appxSearchKeywordResults?keywords=salesforce%20labs"
    }
  ],
  "categories": [
    "integration"
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/salesforce-appexchange-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Salesforce AppExchange Scraper",
        "description": "Extract AppExchange apps, vendors, ratings, categories, pricing, trial signals and listing URLs for Salesforce ecosystem research.",
        "version": "0.1",
        "x-build-id": "fRg57FKy0PC4psavC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~salesforce-appexchange-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-salesforce-appexchange-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~salesforce-appexchange-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-salesforce-appexchange-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~salesforce-appexchange-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-salesforce-appexchange-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on AppExchange, such as marketing automation, CPQ, Salesforce Labs, or data integration.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional AppExchange search URLs or listing detail URLs. Detail URLs must include listingId=... .",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categories": {
                        "title": "Category keywords",
                        "type": "array",
                        "description": "Optional AppExchange category labels/slugs to search, for example marketing, sales, analytics, customer service, or integration.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum AppExchange listing records to save.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include detail-page enrichment",
                        "type": "boolean",
                        "description": "Open each public listing detail page and parse embedded AppExchange state for pricing plans, editions, languages, screenshots, support, and provider details.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```