# Salesforce Consulting Partners Scraper (`automation-lab/salesforce-consulting-partners-scraper`) Actor

Extract Salesforce consulting partner profiles, ratings, credentials, expertise, and AppExchange listing URLs.

- **URL**: https://apify.com/automation-lab/salesforce-consulting-partners-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

## Salesforce Consulting Partners Scraper

Find Salesforce consulting partners, systems integrators, agencies, and implementation experts from the public Salesforce Partner Finder directory.

Use this actor to export partner names, AppExchange profile URLs, headquarters, ratings, review counts, completed projects, credentialed experts, product expertise, cloud accreditations, and public partner badges.

### What does Salesforce Consulting Partners Scraper do?

Salesforce Consulting Partners Scraper turns the public Salesforce Partner Finder directory into structured dataset rows.

It helps you collect:

- 🏢 Partner names and profile IDs
- 🔗 AppExchange consulting listing URLs
- 🌍 Headquarters / location signals
- ⭐ Ratings and review counts
- 📈 Completed project counts
- 🎓 Credentialed expert counts
- ☁️ Salesforce cloud expertise
- 🏷️ Accredited expertise and specializations
- 🤝 Pledge 1% and diverse-owned business badges

### Who is it for?

This actor is useful for teams that need Salesforce ecosystem data in a repeatable workflow.

- 🧭 Channel teams mapping Salesforce partner coverage
- 💼 B2B sales teams building Salesforce SI lead lists
- 🧑‍💼 Recruiters sourcing Salesforce consulting firms
- 📊 Market researchers comparing partner capacity
- 🤝 Alliances teams tracking cloud and industry expertise
- 🧾 M&A analysts screening Salesforce services companies

### Why use this scraper?

The Salesforce Partner Finder is useful in the browser, but manual browsing does not scale.

This actor gives you exportable records that can be loaded into spreadsheets, CRMs, enrichment tools, or BI dashboards.

### Data you can extract

| Field | Description |
| --- | --- |
| `partnerId` | Salesforce internal partner record ID |
| `name` | Consulting partner name |
| `partnerDescription` | Public Salesforce partner description |
| `headquarters` | Headquarters or global location label |
| `profileUrl` | AppExchange consulting listing URL |
| `rating` | Public AppExchange rating |
| `reviewCount` | Number of AppExchange reviews |
| `projectsCompleted` | Public completed project count |
| `credentialedExperts` | Public credentialed expert count |
| `cloudExpertise` | Salesforce cloud expertise labels |
| `accreditedExpertise` | Salesforce accredited expertise labels |
| `expertDistinctions` | Expert distinction labels |
| `pledgeOnePercent` | Public Pledge 1% badge |
| `diverseOwnedBusiness` | Public diverse-owned business badge |

### How much does it cost to scrape Salesforce consulting partners?

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A partner event is charged for each saved partner profile.
- Use `maxItems` to control spend.
- The default input is intentionally small enough for a practical first run.

### Input options

You can run a broad export or narrow the directory with filters.

- `searchTerms` — company, product, industry, or capability keywords
- `maxItems` — maximum unique partners to save
- `countries` — optional country names
- `states` — optional state or region names
- `expertiseNames` — Salesforce product, service, or industry expertise names
- `minRating` — optional minimum rating
- `sortBy` — matching expertise, rating, projects, credentialed experts, or alphabetical
- `includeFilterOptions` — save the live Salesforce filter list to KV store

### Example input

```json
{
  "searchTerms": ["agentforce", "data cloud"],
  "expertiseNames": ["Agentforce"],
  "maxItems": 100,
  "sortBy": "expertise"
}
````

### Output example

```json
{
  "partnerId": "a7f3m000000LKmhAAG",
  "name": "Accenture",
  "headquarters": "Global",
  "profileUrl": "https://appexchange.salesforce.com/listingDetail?listingId=a0N3000000266zBEAQ",
  "rating": 0,
  "reviewCount": 59,
  "projectsCompleted": 18,
  "credentialedExperts": 22623,
  "cloudExpertise": ["Agentforce", "Data 360", "Sales", "Service"],
  "pledgeOnePercent": true
}
```

### How to scrape Salesforce consulting partners

1. Open the actor on Apify.
2. Enter one or more search terms, or leave them empty to browse the directory.
3. Set `maxItems` to the number of partners you need.
4. Optionally add expertise names, countries, or rating filters.
5. Start the run.
6. Download results from the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for better results

- Use broad keywords such as `agentforce`, `data cloud`, `healthcare`, or `manufacturing`.
- Use `includeFilterOptions` once if you want exact Salesforce expertise names.
- Keep `maxItems` small while testing a new filter combination.
- Use `sortBy: "experts"` when credentialed capacity matters most.
- Use `sortBy: "projects"` when delivery history matters most.

### Integrations

You can connect the dataset to:

- HubSpot or Salesforce CRM imports
- Google Sheets lead qualification workflows
- Airtable partner research bases
- BI dashboards for ecosystem coverage
- Recruiting pipelines for Salesforce consulting firms
- M\&A screening spreadsheets

### 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-consulting-partners-scraper').call({
  searchTerms: ['agentforce'],
  maxItems: 50
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/salesforce-consulting-partners-scraper').call(
    run_input={'searchTerms': ['data cloud'], 'maxItems': 50}
)
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~salesforce-consulting-partners-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["agentforce"],"maxItems":50}'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP.

MCP server URL:

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

Claude Code setup:

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

JSON MCP server config:

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

Example prompts:

- "Find 100 Salesforce partners with Agentforce expertise."
- "Export Salesforce consulting partners focused on healthcare."
- "Create a shortlist of Salesforce SIs with high credential counts."

### Legality

This actor extracts public directory information from Salesforce Partner Finder and AppExchange pages.

You should:

- Use the data for legitimate business research.
- Respect Salesforce and AppExchange terms.
- Avoid spam or unsolicited outreach.
- Follow privacy, email, and data protection laws in your jurisdiction.

### FAQ and troubleshooting

#### Why did I get zero results?

Your filters may be too narrow or location labels may not match Salesforce's current labels. Try a search term only, reduce rating filters, or run with `includeFilterOptions` to inspect exact filter names.

#### Why is an expertise name ignored?

Expertise matching is case-insensitive but must match a Salesforce filter option. Save `FILTER_OPTIONS` and copy the exact label.

### Related scrapers

Other automation-lab actors that may fit related workflows:

- https://apify.com/automation-lab/salesforce-appexchange-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/linkedin-company-scraper
- https://apify.com/automation-lab/google-maps-lead-finder

### Limitations

The actor currently focuses on public Partner Finder profile-card data. It does not log into Salesforce, extract private partner portal data, or claim to verify partner availability.

### Performance

The actor uses HTTP requests to the public Salesforce LWR/Apex data path. It does not launch a browser for normal scraping, which keeps runs lightweight.

### Changelog

- Initial version: public Salesforce consulting partner extraction with search, filters, sorting, and structured partner rows.

### Support

If a run fails or a filter behaves unexpectedly, open an Apify issue with your run URL and input. Include whether you used search terms, expertise filters, or location filters.

# Actor input Schema

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

Optional company, capability, industry, or keyword searches. Leave empty to browse all partners.

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

Maximum number of unique partner records to save.

## `countries` (type: `array`):

Optional country names exactly as shown in Partner Finder, for example United States, Germany, India.

## `states` (type: `array`):

Optional state or region names for location-specific partner results.

## `expertiseNames` (type: `array`):

Optional Salesforce product, service, or industry expertise names. Matching is case-insensitive against the public Partner Finder filter list.

## `minRating` (type: `integer`):

Optional minimum AppExchange rating from 1 to 5.

## `sortBy` (type: `string`):

Sort order used by Salesforce Partner Finder.

## `includeFilterOptions` (type: `boolean`):

Save the current Salesforce Partner Finder filter option list to the default key-value store as FILTER\_OPTIONS.

## Actor input object example

```json
{
  "searchTerms": [
    "data cloud",
    "agentforce"
  ],
  "maxItems": 20,
  "countries": [],
  "states": [],
  "expertiseNames": [
    "Agentforce",
    "Data Cloud"
  ],
  "minRating": 0,
  "sortBy": "expertise",
  "includeFilterOptions": 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 = {
    "searchTerms": [
        "data cloud",
        "agentforce"
    ],
    "maxItems": 20,
    "countries": [],
    "states": [],
    "expertiseNames": [
        "Agentforce",
        "Data Cloud"
    ],
    "minRating": 0,
    "sortBy": "expertise",
    "includeFilterOptions": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/salesforce-consulting-partners-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 = {
    "searchTerms": [
        "data cloud",
        "agentforce",
    ],
    "maxItems": 20,
    "countries": [],
    "states": [],
    "expertiseNames": [
        "Agentforce",
        "Data Cloud",
    ],
    "minRating": 0,
    "sortBy": "expertise",
    "includeFilterOptions": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/salesforce-consulting-partners-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 '{
  "searchTerms": [
    "data cloud",
    "agentforce"
  ],
  "maxItems": 20,
  "countries": [],
  "states": [],
  "expertiseNames": [
    "Agentforce",
    "Data Cloud"
  ],
  "minRating": 0,
  "sortBy": "expertise",
  "includeFilterOptions": false
}' |
apify call automation-lab/salesforce-consulting-partners-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Salesforce Consulting Partners Scraper",
        "description": "Extract Salesforce consulting partner profiles, ratings, credentials, expertise, and AppExchange listing URLs.",
        "version": "0.1",
        "x-build-id": "H9qtwIrCJHXzlErFr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~salesforce-consulting-partners-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-salesforce-consulting-partners-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-consulting-partners-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-salesforce-consulting-partners-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-consulting-partners-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-salesforce-consulting-partners-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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional company, capability, industry, or keyword searches. Leave empty to browse all partners.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum partners",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique partner records to save.",
                        "default": 20
                    },
                    "countries": {
                        "title": "Countries",
                        "type": "array",
                        "description": "Optional country names exactly as shown in Partner Finder, for example United States, Germany, India.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "States / regions",
                        "type": "array",
                        "description": "Optional state or region names for location-specific partner results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "expertiseNames": {
                        "title": "Expertise names",
                        "type": "array",
                        "description": "Optional Salesforce product, service, or industry expertise names. Matching is case-insensitive against the public Partner Finder filter list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optional minimum AppExchange rating from 1 to 5.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "expertise",
                            "rating",
                            "projects",
                            "experts",
                            "alphabetical"
                        ],
                        "type": "string",
                        "description": "Sort order used by Salesforce Partner Finder.",
                        "default": "expertise"
                    },
                    "includeFilterOptions": {
                        "title": "Save available filter options",
                        "type": "boolean",
                        "description": "Save the current Salesforce Partner Finder filter option list to the default key-value store as FILTER_OPTIONS.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```