# N8n Template Scraper (`scrapeflow/n8n-template-scraper`) Actor

- **URL**: https://apify.com/scrapeflow/n8n-template-scraper.md
- **Developed by:** [ScrapeFlow](https://apify.com/scrapeflow) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## n8n Template Scraper

A powerful Apify Actor that scrapes n8n workflow templates from the official n8n API. This actor supports category filtering, search queries, custom sorting, and intelligent proxy fallback to ensure reliable data collection.

### Why Choose Us?

- **Intelligent Proxy Management**: Automatically falls back from no proxy → datacenter → residential proxy if requests are blocked, with 3 retries on residential proxy
- **Category Filtering**: Filter templates by category (AI, SecOps, Sales, IT Ops, Marketing, etc.)
- **Search Support**: Search workflows by keywords in apps, roles, or use cases
- **Flexible Sorting**: Sort by relevancy, popularity, or most recent in ascending/descending order
- **Importable Workflows**: Optionally fetch complete importable JSON for each workflow
- **Deduplication**: Automatically removes duplicate templates
- **Concurrent Fetching**: Fast parallel page fetching for efficient data collection
- **Detailed Logging**: Comprehensive logs to track progress and proxy state changes

### Key Features

- ✅ Scrape n8n templates from the official API
- ✅ Category-based filtering (11 categories available)
- ✅ Search query support for keyword-based filtering
- ✅ Custom sorting (relevancy, popularity, most_recent) with direction control
- ✅ Automatic proxy fallback (no proxy → datacenter → residential with retries)
- ✅ Fetch importable workflow JSONs to separate datasets
- ✅ Intelligent retry logic with exponential backoff
- ✅ Automatic deduplication
- ✅ Concurrent page fetching for faster results
- ✅ Live data saving to Apify dataset
- ✅ Support for collecting all workflows (maxWorkflows = 0)

### Input

#### JSON Example

```json
{
  "category": "AI",
  "searchQuery": "Google",
  "sortBy": "relevancy",
  "sortDirection": "desc",
  "maxWorkflows": 100,
  "fetchImportableWorkflows": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Input Fields

- **category** (string, optional): Category of workflows to be collected. Options:

  - `"AI"` - Artificial Intelligence workflows
  - `"SecOps"` - Security Operations
  - `"Sales"` - Sales automation
  - `"IT Ops"` - IT Operations
  - `"Marketing"` - Marketing automation
  - `"Document Ops"` - Document operations
  - `"Engineering"` - Engineering workflows
  - `"DevOps"` - DevOps automation
  - `"HR"` - Human Resources
  - `"Other"` - Other categories
  - `"Support"` - Support workflows

  Default: `"AI"`

- **searchQuery** (string, optional): Search for workflows by keywords in apps, roles, or use cases. Can be used with or without a category filter.

  Default: `"Google"`

- **sortBy** (string, optional): How to sort the workflows. Options:

  - `"relevancy"` - Sort by relevance (default)
  - `"popularity"` - Sort by popularity
  - `"most_recent"` - Sort by most recent

  Default: `"relevancy"`

- **sortDirection** (string, optional): Sort in ascending or descending order. Options:

  - `"asc"` - Ascending order
  - `"desc"` - Descending order (default)

  Default: `"desc"`

- **maxWorkflows** (integer, optional): Maximum number of workflows to collect. Set to `0` to collect all available workflows.

  Default: `10`

  Minimum: `0`

- **fetchImportableWorkflows** (boolean, optional): If enabled, each workflow's importable JSON will be fetched and saved to its own dataset named `workflow-{id}`. If disabled, only the list of workflows will be saved.

  Default: `true`

- **proxyConfiguration** (object, optional): Proxy settings. By default, starts with no proxy (`useApifyProxy: false`). The actor will automatically fallback to datacenter proxy, then residential proxy if requests are blocked. If residential proxy fails, it will retry 3 times before giving up.

### Proxy Logic

The actor implements intelligent proxy fallback logic:

1. **Default**: Starts with **no proxy** (direct connection)
2. **First Fallback**: If the platform rejects or blocks the request, automatically falls back to **datacenter proxy**
3. **Second Fallback**: If datacenter proxy fails, falls back to **residential proxy**
4. **Retry Logic**: If residential proxy fails, retries **3 times** with residential proxy
5. **Persistence**: Once switched to residential proxy, sticks with it for all remaining requests
6. **Logging**: All proxy state changes and retry attempts are clearly logged

All proxy events are logged with clear indicators:

- 🌐 No proxy (direct connection)
- 🔒 Datacenter proxy
- 🔒 Residential proxy
- ⚠️ Request blocked warnings
- 🔄 Fallback and retry attempts
- ✅ Successful proxy switches

### Output

#### Main Dataset: n8n Templates

Each template in the dataset contains:

- **id** (number): Unique template ID
- **name** (string): Template name
- **description** (string): Template description
- **totalViews** (number): Number of views
- **createdAt** (string): Creation date (ISO format)
- **purchaseUrl** (string|null): Purchase URL if available
- **user** (object): Creator information (id, name, username, bio, verified, links, avatar)
- **nodes** (array): List of nodes used in the template
- **url** (string): Direct link to the template on n8n.io

#### Workflow JSON Datasets (if fetchImportableWorkflows is enabled)

If `fetchImportableWorkflows` is set to `true`, each workflow's complete importable JSON will be saved to a separate dataset named `workflow-{id}`. These datasets contain the full workflow configuration that can be imported directly into n8n.

#### Example Output

```json
{
  "id": 6270,
  "name": "Build Your First AI Agent",
  "description": "A comprehensive workflow for building AI agents",
  "totalViews": 99862,
  "createdAt": "2025-07-22T12:14:21.343Z",
  "purchaseUrl": null,
  "user": {
    "id": 91332,
    "name": "Lucas Peyrin",
    "username": "lucaspeyrin",
    "verified": true
  },
  "nodes": ["n8n-nodes-base.httpRequest", "n8n-nodes-base.set"],
  "url": "https://n8n.io/workflows/6270"
}
```

### 🚀 How to Use the Actor (via Apify Console)

1. Log in at https://console.apify.com and go to **Actors**
2. Find your actor (n8n-template-scraper) and click it
3. Configure inputs:
   - Select a category (optional)
   - Enter a search query (optional)
   - Choose sort by and sort direction
   - Set maximum workflows (0 = collect all)
   - Enable/disable fetching importable workflow JSONs
   - Configure proxy settings (optional, defaults to no proxy)
4. Click **Start** to run the actor
5. Monitor logs in real time to see:
   - Progress updates
   - Proxy state changes
   - Fallback attempts
   - Retry attempts
6. Access results in the **OUTPUT** tab
7. Export results to JSON or CSV
8. If importable workflows were fetched, find them in separate datasets named `workflow-{id}`

### Best Use Cases

- **Market Research**: Analyze popular n8n templates by category to understand automation trends
- **Template Discovery**: Find templates by category or search keywords
- **Content Analysis**: Study template structures and node usage patterns
- **Workflow Import**: Collect importable workflow JSONs for direct import into n8n
- **Competitive Intelligence**: Track template creators and their popular workflows
- **Data Collection**: Build a comprehensive database of n8n templates
- **Category Analysis**: Compare templates across different categories (AI, Sales, Marketing, etc.)

### Frequently Asked Questions

**Q: What happens if requests are blocked?**\
A: The actor automatically falls back: no proxy → datacenter proxy → residential proxy (with 3 retries). All proxy state changes are logged clearly.

**Q: Can I filter by category and search at the same time?**\
A: Yes! You can use both `category` and `searchQuery` together to narrow down results.

**Q: What does maxWorkflows = 0 mean?**\
A: Setting `maxWorkflows` to `0` will collect all available workflows matching your filters.

**Q: What are importable workflow JSONs?**\
A: These are complete workflow configurations that can be directly imported into n8n. They're saved to separate datasets named `workflow-{id}`.

**Q: How are duplicates handled?**\
A: Templates are automatically deduplicated based on their unique ID.

**Q: How long does it take to fetch templates?**\
A: It depends on the number of templates and whether importable JSONs are fetched. Typically, 100 templates take 30-60 seconds, 1000 templates take 2-5 minutes.

**Q: Can I use custom proxy?**\
A: Yes, you can configure a custom proxy in the `proxyConfiguration` object with `customProxy` containing `hostname`, `port`, `username`, and `password`.

### Support and Feedback

For issues, questions, or feature requests, please contact us at **dev.scraperengine@gmail.com**.

### Cautions

- Data is collected only from **publicly available sources** on the n8n API
- The actor respects rate limits and implements retry logic
- The end user is responsible for ensuring legal compliance with data usage
- Make sure you have sufficient Apify credits for large-scale scraping operations
- Fetching importable workflow JSONs increases execution time and API calls

# Actor input Schema

## `category` (type: `string`):

🏷️ Pick a workflow theme. Optional — mix with search below.

## `searchQuery` (type: `string`):

✍️ Keywords in apps, roles, or use cases. Works with or without a category filter.

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

🧭 What to optimize for: relevance, popularity, or recency.

## `sortDirection` (type: `string`):

📊 Ascending (A→Z, oldest first) or descending (Z→A, newest first) — depending on field.

## `maxWorkflows` (type: `integer`):

🎯 How many templates to return. Use 0 to fetch everything the API allows in your run (still subject to platform limits).

## `fetchImportableWorkflows` (type: `boolean`):

✅ On: fetch each template’s import-ready JSON and store it in a named dataset (workflow-{id}).
📋 Off: only the list view / summary rows in the main dataset (lighter and faster).

## `proxyConfiguration` (type: `object`):

⚡ Recommended for stability at scale — fewer blocks and fewer retries.

🚦 Default: no proxy → fastest first hop.
1️⃣ Datacenter if needed
2️⃣ Residential if still blocked

## Actor input object example

```json
{
  "category": "AI",
  "searchQuery": "Google",
  "sortBy": "relevancy",
  "sortDirection": "desc",
  "maxWorkflows": 10,
  "fetchImportableWorkflows": true,
  "proxyConfiguration": {
    "useApifyProxy": false,
    "apifyProxyGroups": []
  }
}
```

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": false,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeflow/n8n-template-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 = { "proxyConfiguration": {
        "useApifyProxy": False,
        "apifyProxyGroups": [],
    } }

# Run the Actor and wait for it to finish
run = client.actor("scrapeflow/n8n-template-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 '{
  "proxyConfiguration": {
    "useApifyProxy": false,
    "apifyProxyGroups": []
  }
}' |
apify call scrapeflow/n8n-template-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "N8n Template Scraper",
        "version": "0.1",
        "x-build-id": "AlDUkLWh4ap9gUsSB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeflow~n8n-template-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeflow-n8n-template-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/scrapeflow~n8n-template-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeflow-n8n-template-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/scrapeflow~n8n-template-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeflow-n8n-template-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": {
                    "category": {
                        "title": "🗂️ Category",
                        "enum": [
                            "AI",
                            "SecOps",
                            "Sales",
                            "IT Ops",
                            "Marketing",
                            "Document Ops",
                            "Engineering",
                            "DevOps",
                            "HR",
                            "Other",
                            "Support"
                        ],
                        "type": "string",
                        "description": "🏷️ Pick a workflow theme. Optional — mix with search below.",
                        "default": "AI"
                    },
                    "searchQuery": {
                        "title": "🔎 Search query",
                        "type": "string",
                        "description": "✍️ Keywords in apps, roles, or use cases. Works with or without a category filter.",
                        "default": "Google"
                    },
                    "sortBy": {
                        "title": "🔀 Sort by",
                        "enum": [
                            "relevancy",
                            "popularity",
                            "most_recent"
                        ],
                        "type": "string",
                        "description": "🧭 What to optimize for: relevance, popularity, or recency.",
                        "default": "relevancy"
                    },
                    "sortDirection": {
                        "title": "⬆️⬇️ Sort direction",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "📊 Ascending (A→Z, oldest first) or descending (Z→A, newest first) — depending on field.",
                        "default": "desc"
                    },
                    "maxWorkflows": {
                        "title": "🔢 Max workflows",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🎯 How many templates to return. Use 0 to fetch everything the API allows in your run (still subject to platform limits).",
                        "default": 10
                    },
                    "fetchImportableWorkflows": {
                        "title": "📥 Importable JSON per workflow",
                        "type": "boolean",
                        "description": "✅ On: fetch each template’s import-ready JSON and store it in a named dataset (workflow-{id}).\n📋 Off: only the list view / summary rows in the main dataset (lighter and faster).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy (optional)",
                        "type": "object",
                        "description": "⚡ Recommended for stability at scale — fewer blocks and fewer retries.\n\n🚦 Default: no proxy → fastest first hop.\n1️⃣ Datacenter if needed\n2️⃣ Residential if still blocked"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```