# Ecwid App Market Scraper (`automation-lab/ecwid-app-market-scraper`) Actor

Scrape Ecwid App Market app listings with vendors, categories, pricing, descriptions, icons, and install links for ecommerce research.

- **URL**: https://apify.com/automation-lab/ecwid-app-market-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Ecwid App Market Scraper

Extract structured app listings from the public Ecwid App Market for ecommerce competitive intelligence, partner research, app positioning, and marketplace monitoring.

### What does Ecwid App Market Scraper do?

Ecwid App Market Scraper collects public app marketplace data from `ecwid.com/apps` and category pages.
It turns Ecwid's embedded app catalog into clean dataset rows that are easy to export, filter, enrich, and monitor.

The actor can capture:

- 🧩 App names and Ecwid namespaces
- 🏢 Developers and vendors
- 🗂️ Categories and primary category
- 💬 Short and long app descriptions
- 💸 Pricing text, free flags, and free-trial signals
- 🔗 Public app URLs and Ecwid install deep links
- 🖼️ Icons and header images
- 🕒 Source URL and scrape timestamp

### Who is it for?

#### Ecommerce app vendors

Use the scraper to monitor competing Ecwid apps, compare messaging, track pricing claims, and find positioning gaps.

#### Agencies and implementation partners

Build lists of Ecwid integrations to recommend to merchants or to identify app vendors for partnership outreach.

#### Marketplace analysts

Track category composition, pricing models, vendor concentration, and app-market trends across the Ecwid ecosystem.

#### Lead generation teams

Find app developers, tool vendors, and integration partners that are already active in the Ecwid/Lightspeed merchant ecosystem.

### Why use this actor?

The Ecwid App Market is useful for competitive research, but copying app records manually is slow and error-prone.
This actor extracts the public catalog directly from Ecwid pages and saves consistent fields to an Apify dataset.

### Typical use cases

- Monitor newly listed Ecwid apps
- Compare pricing and free-trial language across categories
- Build ecommerce app vendor lead lists
- Analyze app-market category coverage
- Enrich CRM records with marketplace URLs and icons
- Watch competitor copy and descriptions over time

### What data can you extract?

| Field | Description |
| --- | --- |
| `appName` | Public Ecwid app title |
| `namespace` | Stable Ecwid app namespace |
| `developer` | Vendor or developer name |
| `category` | Primary category |
| `categories` | All categories listed in the embedded catalog |
| `shortDescription` | Marketplace summary |
| `fullDescription` | Cleaned long description when enabled |
| `pricing` | Public pricing text |
| `isFree` | Boolean free indicator when available |
| `hasFreeTrial` | Whether pricing mentions a free trial |
| `appUrl` | Public app detail URL |
| `installUrl` | Ecwid control-panel install/deep link |
| `iconUrl` | App icon URL |
| `headerImageUrl` | App header/hero image URL |
| `sourceListUrl` | Listing page used as source |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Ecwid apps?

This actor uses pay-per-event pricing.
You pay a small start fee and then a per-result fee for each Ecwid app record saved.
The default input is intentionally small enough for a quick first run, while `maxItems` lets you scale to the full marketplace.

### Input options

#### Start URLs

Use the main Ecwid app market URL or specific category/list pages:

```json
[
  { "url": "https://www.ecwid.com/apps" }
]
````

#### Category filters

Add category names such as:

- Marketing
- Tools
- Dropshipping
- Shipping
- Accounting
- Design

#### Search terms

Use keywords to focus on a niche, for example:

- email
- reviews
- shipping
- print on demand
- loyalty

#### Maximum apps

Set `maxItems` to cap the number of dataset records.

#### Include full descriptions

Turn `includeFullDescription` off if you only need compact rows.
Leave it on when you want richer text for analysis or embeddings.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.ecwid.com/apps" }
  ],
  "categories": ["Marketing"],
  "searchTerms": ["email", "newsletter"],
  "maxItems": 100,
  "includeFullDescription": true
}
```

### Example output

```json
{
  "appName": "Newsletters with Mailchimp",
  "namespace": "mailchimp-integration",
  "developer": "Ecwid",
  "category": null,
  "categories": [],
  "shortDescription": "Connect your Ecwid store to Mailchimp...",
  "pricing": "Free",
  "isFree": true,
  "hasFreeTrial": false,
  "appUrl": "https://www.ecwid.com/apps/mailchimp-integration",
  "installUrl": "https://my.ecwid.com/cp/#apps:view=mailchimp-integration",
  "iconUrl": "https://.../app-icon.png",
  "sourceListUrl": "https://www.ecwid.com/apps",
  "scrapedAt": "2026-07-06T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Keep the prefilled `https://www.ecwid.com/apps` start URL or add category URLs.
3. Optionally set `categories` or `searchTerms`.
4. Choose `maxItems`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Tips for better results

- Use no filters to export the broad marketplace.
- Use category filters for category-level competitive research.
- Use search terms for niche workflows such as email, loyalty, shipping, reviews, or print-on-demand.
- Keep `includeFullDescription` enabled for AI enrichment and semantic search.
- Schedule daily or weekly runs to monitor changes.

### Integrations

You can connect the dataset to:

- Google Sheets for analyst review
- Airtable for app-vendor CRM lists
- Make or Zapier for alerts
- BI tools for category dashboards
- Vector databases for app-market semantic search
- Email outreach tools for partner prospecting

### 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/ecwid-app-market-scraper').call({
  startUrls: [{ url: 'https://www.ecwid.com/apps' }],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/ecwid-app-market-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.ecwid.com/apps'}],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

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

### MCP usage

Use this actor from Claude Desktop, Claude Code, or another MCP client with Apify MCP Server:

```text
https://mcp.apify.com/?tools=automation-lab/ecwid-app-market-scraper
```

Claude Code setup:

```bash
claude mcp add apify-ecwid-apps https://mcp.apify.com/?tools=automation-lab/ecwid-app-market-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Scrape the Ecwid App Market and summarize the most common pricing models."
- "Find Ecwid apps related to email marketing and return app names, vendors, and install links."
- "Monitor Ecwid app categories weekly and highlight new tools."

### Scheduling

Schedule recurring runs on Apify to track category changes and new app launches.
Use dataset exports or webhooks to push changes to your internal workflow.

### Data freshness

The actor scrapes public Ecwid pages at run time.
Each row includes `scrapedAt` and `sourceListUrl` so you can compare snapshots over time.

### Limitations

Ecwid may load some rating details with client-side helpers that are not present in the embedded catalog JSON.
The MVP focuses on stable app listing, vendor, category, description, pricing, icon, and link fields.

### Legality

The actor extracts publicly available marketplace listing information.
You should use the data responsibly, respect applicable laws, and avoid using exported contact or business data for spam or prohibited outreach.

### FAQ

#### Does this actor need an Ecwid login?

No. It scrapes public Ecwid App Market pages and does not require merchant account credentials.

#### Can I scrape one specific category?

Yes. Use `categories` for category filters or add a category page to `startUrls`.

### Troubleshooting

#### I got zero results

Remove category and search filters, then run with only `https://www.ecwid.com/apps` and a small `maxItems` value.

#### I do not see ratings

Rating widgets may be loaded separately by Ecwid's frontend. Use the core marketplace fields for reliable monitoring.

#### My category has fewer results than expected

Category names can differ from marketing labels. Try running without a category filter and filter the exported dataset manually.

### Related scrapers

Explore other Automation Lab ecommerce and marketplace actors:

- https://apify.com/automation-lab/bigcommerce-apps-scraper
- https://apify.com/automation-lab/zoho-marketplace-scraper
- https://apify.com/automation-lab/monday-apps-marketplace-scraper
- https://apify.com/automation-lab/shopify-app-store-scraper

### Changelog

#### 0.1

Initial version with HTTP extraction from Ecwid App Market embedded catalog arrays.

### Support

If you need a missing field or a related ecommerce marketplace scraper, open an issue on the Apify actor page.

# Actor input Schema

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

Ecwid App Market listing or category pages to scan. Leave the prefilled URL to scrape the main app market.

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

Optional Ecwid category names or slugs to fetch/filter, such as Marketing, Tools, Dropshipping, Accounting, Shipping, or Design.

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

Optional keywords matched against app name, developer, category, pricing, and descriptions.

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

Maximum number of Ecwid app records to save.

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

Save cleaned long app descriptions in addition to short summaries.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.ecwid.com/apps"
    }
  ],
  "categories": [
    "Marketing"
  ],
  "searchTerms": [],
  "maxItems": 20,
  "includeFullDescription": 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://www.ecwid.com/apps"
        }
    ],
    "categories": [
        "Marketing"
    ],
    "searchTerms": [],
    "maxItems": 20,
    "includeFullDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ecwid-app-market-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://www.ecwid.com/apps" }],
    "categories": ["Marketing"],
    "searchTerms": [],
    "maxItems": 20,
    "includeFullDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ecwid-app-market-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://www.ecwid.com/apps"
    }
  ],
  "categories": [
    "Marketing"
  ],
  "searchTerms": [],
  "maxItems": 20,
  "includeFullDescription": true
}' |
apify call automation-lab/ecwid-app-market-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ecwid App Market Scraper",
        "description": "Scrape Ecwid App Market app listings with vendors, categories, pricing, descriptions, icons, and install links for ecommerce research.",
        "version": "0.1",
        "x-build-id": "x07VvS5mContFWQPW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ecwid-app-market-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ecwid-app-market-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~ecwid-app-market-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ecwid-app-market-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~ecwid-app-market-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ecwid-app-market-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": "Ecwid App Market listing or category pages to scan. Leave the prefilled URL to scrape the main app market.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categories": {
                        "title": "Category filters",
                        "type": "array",
                        "description": "Optional Ecwid category names or slugs to fetch/filter, such as Marketing, Tools, Dropshipping, Accounting, Shipping, or Design.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional keywords matched against app name, developer, category, pricing, and descriptions.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Ecwid app records to save.",
                        "default": 20
                    },
                    "includeFullDescription": {
                        "title": "Include full descriptions",
                        "type": "boolean",
                        "description": "Save cleaned long app descriptions in addition to short summaries.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```