# Stripe App Marketplace Scraper (`automation-lab/stripe-app-marketplace-scraper`) Actor

Scrape Stripe App Marketplace apps, vendor details, pricing signals, install links, categories, and integration metadata for SaaS research.

- **URL**: https://apify.com/automation-lab/stripe-app-marketplace-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

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

## Stripe App Marketplace Scraper

Extract structured Stripe App Marketplace data for partnership research, app-marketplace monitoring, competitive intelligence, and lead enrichment.

### What does Stripe App Marketplace Scraper do?

Stripe App Marketplace Scraper collects public app listings from `marketplace.stripe.com` and returns clean records with app names, vendor details, categories, descriptions, pricing signals, install links, support links, policy links, and technical metadata.

Use it when you need a spreadsheet or API feed of companies building in the Stripe ecosystem.

### Who is it for?

- 🤝 Partnership teams mapping potential Stripe integration partners.
- 🧭 Product teams comparing payment ecosystem apps and feature gaps.
- 📈 Competitive-intelligence teams monitoring new fintech and SaaS apps.
- 🧾 RevOps teams enriching account lists with marketplace presence.
- 🛠️ Developer-relations teams tracking apps by category and capability.

### Why use this actor?

The Stripe marketplace is useful but manual browsing is slow. This actor turns the public marketplace into a repeatable dataset with URLs and normalized fields that are easy to export, join, deduplicate, or monitor.

### What data can it extract?

| Field | Description |
| --- | --- |
| `name` | App listing name |
| `safeName` | Stripe URL-safe app slug |
| `marketplaceUrl` | Public Stripe app listing URL |
| `subtitle` | Short listing tagline |
| `description` | Detail-page app description |
| `developer` | Vendor or developer name |
| `categories` | Stripe category IDs |
| `categoryNames` | Human-readable category names |
| `pricingType` | Public pricing type value when available |
| `hasFreeTrial` | Free-trial flag when exposed |
| `installUrl` | Stripe or external install URL |
| `websiteUrl` | Vendor website |
| `supportUrl` | Support site URL |
| `supportEmail` | Support email when available |
| `privacyPolicyUrl` | Privacy policy URL |
| `termsUrl` | Terms URL |
| `faqUrl` | FAQ URL |
| `technicalDocUrl` | Technical documentation URL |
| `logoUrl` | Listing logo URL |
| `keyFeatures` | Feature cards and media |
| `worksWith` | Stripe product compatibility values |
| `permissions` | App permission metadata |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Stripe marketplace apps?

This actor uses pay-per-event pricing: a small run-start fee plus a per-app result event. You only pay for the records produced by your run. Use `maxItems` to cap cost during testing.

### Quick start

1. Open the actor on Apify.
2. Keep the default Stripe Marketplace URL.
3. Set `maxItems` to the number of apps you want.
4. Optionally add search terms such as `accounting`, `crm`, or `subscription`.
5. Run the actor and export the dataset as CSV, JSON, Excel, or via API.

### Input options

#### Start URLs

Use `startUrls` for broad marketplace runs or individual app pages.

Example:

```json
[
  { "url": "https://marketplace.stripe.com/" },
  { "url": "https://marketplace.stripe.com/apps/slack" }
]
````

### Search terms

Use `searchTerms` to query the public marketplace search endpoint.

```json
{
  "searchTerms": ["accounting", "subscription", "analytics"],
  "maxItems": 250
}
```

### Category filters

Use `categories` to keep only specific marketplace categories. You can provide IDs or readable names.

```json
{
  "categories": ["accounting", "revenue optimization"],
  "maxItems": 100
}
```

### Detail mode

`includeDetails` is enabled by default. It fetches each app detail endpoint for richer descriptions, key features, install links, and policy URLs. Disable it for faster lightweight list exports.

### Example input

```json
{
  "startUrls": [{ "url": "https://marketplace.stripe.com/" }],
  "searchTerms": ["accounting"],
  "categories": [],
  "maxItems": 100,
  "includeDetails": true
}
```

### Example output

```json
{
  "name": "Example App",
  "safeName": "example-app",
  "marketplaceUrl": "https://marketplace.stripe.com/apps/example-app",
  "developer": "Example Vendor",
  "categoryNames": ["Accounting"],
  "pricingType": "free",
  "hasFreeTrial": true,
  "websiteUrl": "https://example.com",
  "scrapedAt": "2026-07-05T00:00:00.000Z"
}
```

### Business workflows

#### Partner discovery

Export vendors in payment-adjacent categories and route them into a CRM for outreach.

#### Competitive monitoring

Schedule recurring runs and compare new `safeName` values to detect newly listed Stripe apps.

#### Category mapping

Group apps by `categoryNames` to understand where Stripe has strong or weak app coverage.

#### Lead enrichment

Join `websiteUrl`, `developer`, and `marketplaceUrl` with existing account lists.

### Tips for best results

- Start with `maxItems: 100` for a realistic sample.
- Use search terms to focus on a niche workflow.
- Keep `includeDetails` enabled when you need support, privacy, terms, or technical-documentation URLs.
- Use category filters when you need a clean segment instead of the full marketplace.

### Integrations

Send the dataset to Google Sheets, Airtable, Snowflake, BigQuery, HubSpot, Salesforce, or your internal data warehouse using Apify integrations, webhooks, or the API.

### 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/stripe-app-marketplace-scraper').call({
  startUrls: [{ url: 'https://marketplace.stripe.com/' }],
  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/stripe-app-marketplace-scraper').call(run_input={
    'startUrls': [{'url': 'https://marketplace.stripe.com/'}],
    'maxItems': 100,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

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

### MCP usage

Use this actor from Claude or other MCP-compatible tools through Apify MCP:

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

Add it in Claude Code:

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

MCP server JSON configuration:

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

Example prompts:

- "Scrape 100 Stripe marketplace apps in accounting and summarize top vendors."
- "Find Stripe marketplace apps with support URLs and website links for partnership outreach."
- "Monitor Stripe App Marketplace for new revenue optimization apps."

### Scheduling

Create an Apify schedule to run weekly or monthly. Compare new runs to previous datasets by `safeName` to detect marketplace changes.

### Data quality

The actor uses Stripe's public marketplace JSON endpoints. Fields are returned when Stripe exposes them; some apps may omit support emails, pricing URLs, or detailed feature cards.

### Performance

This is an HTTP-only actor and does not launch a browser. It is designed to run efficiently at 256 MB memory.

### Limitations

The actor does not log into Stripe and does not access private account data. It only extracts public marketplace listing metadata.

### Legality

This actor extracts publicly available marketplace data. Review Stripe's terms and your own use case before running large or recurring crawls. Do not use extracted data for spam or prohibited outreach.

### Troubleshooting

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

Check `maxItems`, search terms, and category filters. Filters are applied before records are saved.

#### Why is a URL field empty?

Some Stripe listings do not expose every link. Empty values mean the public listing or detail endpoint did not provide that field.

### Related scrapers

Explore other Automation Lab marketplace and SaaS ecosystem scrapers on Apify:

- https://apify.com/automation-lab/hubspot-app-marketplace-scraper
- https://apify.com/automation-lab/atlassian-marketplace-scraper
- https://apify.com/automation-lab/bigcommerce-apps-scraper
- https://apify.com/automation-lab/aws-marketplace-scraper

### Changelog

- Initial version extracts Stripe Marketplace app listings and app detail metadata.

### Support

If a marketplace page changes or you need additional fields, open an issue on the actor page with an example app URL and desired output.

### Field reference

`id`

`name`

`safeName`

`marketplaceUrl`

`subtitle`

`description`

`developer`

`developerId`

`basedIn`

`categories`

`categoryNames`

`capabilityTypes`

`worksWith`

`permissions`

`pricingType`

`hasFreeTrial`

`pricingDetailsUrl`

`installType`

`installCta`

`installUrl`

`websiteUrl`

`supportUrl`

`supportEmail`

`privacyPolicyUrl`

`termsUrl`

`faqUrl`

`technicalDocUrl`

`logoUrl`

`keyFeatures`

`supportedLanguages`

`status`

`isLive`

`comingSoon`

`listingVersion`

`sourceUrl`

`scrapedAt`

# Actor input Schema

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

Optional Stripe Marketplace URLs. Use the marketplace home page, category/search pages, or app detail URLs such as https://marketplace.stripe.com/apps/slack.

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

Optional Stripe Marketplace search terms. Example: accounting, CRM, subscription, analytics.

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

Optional category IDs or names to keep, e.g. accounting, revenue\_optimization, email\_marketing. Leave empty to scrape all categories.

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

Maximum number of Stripe Marketplace app records to save.

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

Fetch each app detail endpoint for richer descriptions, key features, install links, support links, and policy URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://marketplace.stripe.com/"
    }
  ],
  "searchTerms": [
    "accounting"
  ],
  "categories": [],
  "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 = {
    "startUrls": [
        {
            "url": "https://marketplace.stripe.com/"
        }
    ],
    "searchTerms": [
        "accounting"
    ],
    "categories": [],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/stripe-app-marketplace-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://marketplace.stripe.com/" }],
    "searchTerms": ["accounting"],
    "categories": [],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/stripe-app-marketplace-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://marketplace.stripe.com/"
    }
  ],
  "searchTerms": [
    "accounting"
  ],
  "categories": [],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/stripe-app-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stripe App Marketplace Scraper",
        "description": "Scrape Stripe App Marketplace apps, vendor details, pricing signals, install links, categories, and integration metadata for SaaS research.",
        "version": "0.1",
        "x-build-id": "lpHCgP5wmIrsK5CEZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~stripe-app-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-stripe-app-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~stripe-app-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-stripe-app-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~stripe-app-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-stripe-app-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional Stripe Marketplace URLs. Use the marketplace home page, category/search pages, or app detail URLs such as https://marketplace.stripe.com/apps/slack.",
                        "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 Stripe Marketplace search terms. Example: accounting, CRM, subscription, analytics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Category filters",
                        "type": "array",
                        "description": "Optional category IDs or names to keep, e.g. accounting, revenue_optimization, email_marketing. Leave empty to scrape all categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Stripe Marketplace app records to save.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include app details",
                        "type": "boolean",
                        "description": "Fetch each app detail endpoint for richer descriptions, key features, install links, support links, and policy URLs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
