# Remote Work Hub Market Analyzer (`trovevault/remote-work-hub-market-analyzer`) Actor

Compare cities for remote work and coworking market opportunity with opportunityScore, benchmark deltas, internetQualityScore, and recommendedAction.

- **URL**: https://apify.com/trovevault/remote-work-hub-market-analyzer.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Travel, Jobs, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 cities

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

## Remote Work Hub Market Analyzer

Compare cities for remote-work hub opportunity. This actor helps coworking operators, coliving operators, tourism boards, real estate developers, and distributed teams decide which destinations deserve deeper research, expansion planning, partnership outreach, or relocation review.

It returns one decision row per location with `opportunityScore`, `marketStage`, `recommendedAction`, benchmark comparison, coworking, density, internet, community, affordability, saturation, and coliving gap scores.

This is an analyzer, not a raw directory scraper. You provide target cities and a buyer profile; the actor resolves public sources internally and produces a buyer-facing market signal.

### Why Use This Actor

Remote-work destinations are often evaluated through city guides, coworking directories, blog posts, cost pages, and subjective community chatter. That is slow to compare and easy to overfit to search results.

This actor turns the workflow into a repeatable benchmark:

| Question | Output fields |
| --- | --- |
| Which city looks strongest for this buyer profile? | `opportunityScore`, `relativePosition` |
| Is the market already crowded? | `osmCoworkingCount`, `coworkingSupplySignal`, `saturationRiskSignal` |
| Is there a possible live-work or coliving gap? | `colivingGapSignal`, `communityMomentumSignal` |
| What should the buyer do next? | `recommendedAction`, `marketStage` |
| How does the city compare with alternatives? | `benchmarkAgainst`, `betterThanBenchmarksOn`, `worseThanBenchmarksOn` |

### Data Strategy

The actor uses stable public sources and internal scoring rules:

- **Nominatim / OpenStreetMap** to resolve city identity and bounding boxes.
- **OpenStreetMap Overpass API** to count features tagged `office=coworking` inside the resolved city area.
- **Wikivoyage summary API** for lightweight city context when available.
- **Internal destination context** for known remote-work areas, broad affordability pressure tiers, and fallback coworking counts for selected hubs when Overpass temporarily fails.

The actor does **not** use Numbeo. It also does not rely on Teleport, Nomad List, Coworker, Coliving.com, Expatistan, or Speedtest/Ookla as core sources.

### Use Cases

- **Coworking operators:** compare expansion targets and spot underserved, competitive, or mature hubs.
- **Coliving operators:** identify cities where community and workspace signals suggest live-work demand.
- **Tourism boards and DMOs:** benchmark destinations before promoting remote-work programmes.
- **Real estate developers:** screen cities for flexible workspace or mixed-use concepts.
- **Remote teams:** compare hubs for meetups, relocation shortlists, or distributed office planning.

### Input

The input is intentionally short. Users do not choose sources; source resolution is part of the actor.

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `locations` | array | yes | Cities to analyze, ideally with country context. |
| `buyerProfile` | string | no | Decision lens: `coworking_operator`, `coliving_operator`, `tourism_board`, `real_estate_developer`, or `remote_team`. |
| `benchmarkAgainst` | array | no | Optional comparison cities. Leave blank to use the default benchmark set for the buyer profile. |
| `datasetId` | string | no | Existing Apify dataset to append rows to as well as the default run dataset. |
| `runId` | string | no | Optional external batch or run ID copied into output rows. |

#### Example Input

```json
{
  "locations": ["Lisbon, Portugal"],
  "buyerProfile": "coworking_operator",
  "benchmarkAgainst": ["Porto, Portugal"]
}
````

### Output

Each dataset row is a decision record for one target location.

```json
{
  "location": "Lisbon, Portugal",
  "city": "Lisbon",
  "country": "Portugal",
  "region": "Europe",
  "buyerProfile": "coworking_operator",
  "opportunityScore": 63,
  "marketStage": "competitive_growth_market",
  "recommendedAction": "Consider differentiated coworking, niche communities, or partnerships instead of a generic workspace launch.",
  "relativePosition": "above_benchmark_average",
  "benchmarkAgainst": ["Barcelona, Spain", "Medellin, Colombia", "Chiang Mai, Thailand"],
  "betterThanBenchmarksOn": ["workspace_density", "internet_readiness"],
  "worseThanBenchmarksOn": ["affordability_pressure"],
  "osmCoworkingCount": 37,
  "coworkingSupplyScore": 92,
  "coworkingSupplySignal": "strong",
  "workspaceDensityPerKm2": 0.08,
  "workspaceDensityScore": 71,
  "workspaceDensitySignal": "moderate",
  "internetQualityScore": 82,
  "internetReadinessSignal": "strong",
  "communityMomentumScore": 88,
  "communityMomentumSignal": "strong",
  "affordabilityPressure": "high",
  "affordabilityRiskScore": 78,
  "saturationRiskScore": 73,
  "saturationRiskSignal": "medium",
  "colivingGapScore": 58,
  "colivingGapSignal": "moderate",
  "exampleCoworkingSpaces": ["Heden", "Impact Hub Lisbon", "Second Home Lisboa"],
  "knownRemoteWorkAreas": ["Santos", "Cais do Sodre", "Principe Real", "Anjos", "Marvila"]
}
```

### Key Fields

| Field | Meaning |
| --- | --- |
| `opportunityScore` | Buyer-specific 0 to 100 opportunity score. |
| `marketStage` | Practical market tier, such as `underserved_opportunity`, `competitive_growth_market`, or `mature_competitive_hub`. |
| `recommendedAction` | Plain-English next action for the selected buyer profile. |
| `relativePosition` | Whether the location is above, below, or near the benchmark average. |
| `betterThanBenchmarksOn` | Signals where the city beats the benchmark average. |
| `worseThanBenchmarksOn` | Signals where the city lags the benchmark average. |
| `osmCoworkingCount` | Count of mapped OpenStreetMap coworking features, with internal fallback counts for selected known hubs when Overpass temporarily fails. This is a public map signal, not a complete market census. |
| `coworkingSupplyScore` | 0 to 100 score for mapped coworking supply. |
| `workspaceDensityPerKm2` | Coworking map count divided by approximate bounding-box area. |
| `workspaceDensityScore` | 0 to 100 score for mapped coworking density. |
| `internetQualityScore` | 0 to 100 internet-readiness score for remote-work decisions. It is not a measured Mbps result. |
| `communityMomentumScore` | 0 to 100 score for remote-work community momentum. |
| `affordabilityPressure` | Broad pressure tier from internal context. The actor does not return exact monthly costs. |
| `affordabilityRiskScore` | 0 to 100 score where higher means more affordability pressure. |
| `saturationRiskScore` | 0 to 100 score where higher means a more competitive or mature market. |
| `colivingGapScore` | 0 to 100 score for possible live-work market gap. |

### API Usage

```bash
curl "https://api.apify.com/v2/acts/trovevault~remote-work-hub-market-analyzer/runs" \
  -X POST \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "locations": ["Lisbon, Portugal"],
    "buyerProfile": "coworking_operator",
    "benchmarkAgainst": ["Porto, Portugal"]
  }'
```

After the run finishes, fetch rows from the default dataset:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

### How Benchmarks Work

`benchmarkAgainst` is optional. It changes the output from "this city has a score" to "this city is stronger or weaker than the comparison set on specific business signals." If blank, the actor uses a default comparison set for the selected `buyerProfile`.

### Limitations

- OpenStreetMap coverage varies by city. `osmCoworkingCount` is a mapped public signal, not a complete list of every coworking operator.
- For selected known hubs, the actor may use an internal fallback coworking count when Overpass returns a temporary error. The fallback is recorded in `RUN_SUMMARY`, not in public dataset rows.
- The actor does not scrape Numbeo and does not output exact cost-of-living estimates.
- Internet readiness is a tiered decision signal, not a measured Mbps speed-test result.
- Wikivoyage summaries may be missing or generic for some destinations.
- This actor is designed for screening and prioritization. High-stakes expansion, leasing, tourism-budget, or relocation decisions should still include manual due diligence.
- Source diagnostics are stored in `RUN_SUMMARY` so public dataset rows stay focused on the buyer decision.

### FAQ

#### Does this actor scrape Nomad List, Teleport, Coworker, or Coliving.com?

No. Those sources are not used as core sources in this MVP. The actor is built around more stable public map and destination signals.

#### Does this actor use Numbeo?

No. Numbeo is intentionally excluded.

#### Why is the coworking count lower than a commercial directory?

The count comes from OpenStreetMap features tagged `office=coworking`. It is useful as a comparable public mapping signal, but it is not a full commercial inventory.

#### Can I schedule it?

Yes. Schedule the actor in Apify and keep the same benchmark set to monitor how relative signals change over time.

#### Can I append results to an existing dataset?

Yes. Pass `datasetId` and the actor will push rows to both the default run dataset and that dataset.

### Changelog

#### 0.1.0

- Pivoted from a broad digital nomad scraper to a B2B remote-work hub market opportunity analyzer.
- Removed source picker inputs.
- Removed Numbeo and other fragile/proprietary sources from the core workflow.
- Added benchmark comparison, buyer-profile weighting, market stage, and recommended action fields.

# Actor input Schema

## `locations` (type: `array`):

Cities to analyze for remote-work market opportunity. Use city and country when possible, for example `Lisbon, Portugal`, `Porto, Portugal`, or `Barcelona, Spain`. The actor returns one decision row per location.

## `buyerProfile` (type: `string`):

The business profile behind the analysis. A coworking operator sees a different opportunity score than a tourism board, coliving operator, real estate developer, or remote team.

## `benchmarkAgainst` (type: `array`):

Cities to use as a comparison set. This makes the output relative, for example whether Lisbon is above or below Porto on coworking supply, workspace density, community momentum, and opportunity score. Leave blank for actor-owned default benchmarks.

## `datasetId` (type: `string`):

ID of an existing Apify dataset to append results to, in addition to the default run dataset. Leave blank for normal runs.

## `runId` (type: `string`):

Optional external run or client batch ID. When supplied, it is copied to each output row.

## Actor input object example

```json
{
  "locations": [
    "Lisbon, Portugal"
  ],
  "buyerProfile": "coworking_operator",
  "benchmarkAgainst": [
    "Porto, Portugal"
  ]
}
```

# Actor output Schema

## `dataset` (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 = {
    "locations": [
        "Lisbon, Portugal"
    ],
    "buyerProfile": "coworking_operator",
    "benchmarkAgainst": [
        "Porto, Portugal"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/remote-work-hub-market-analyzer").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 = {
    "locations": ["Lisbon, Portugal"],
    "buyerProfile": "coworking_operator",
    "benchmarkAgainst": ["Porto, Portugal"],
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/remote-work-hub-market-analyzer").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 '{
  "locations": [
    "Lisbon, Portugal"
  ],
  "buyerProfile": "coworking_operator",
  "benchmarkAgainst": [
    "Porto, Portugal"
  ]
}' |
apify call trovevault/remote-work-hub-market-analyzer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/remote-work-hub-market-analyzer",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Remote Work Hub Market Analyzer",
        "description": "Compare cities for remote work and coworking market opportunity with opportunityScore, benchmark deltas, internetQualityScore, and recommendedAction.",
        "version": "0.1",
        "x-build-id": "wkgY82fzJG1gNwtRw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~remote-work-hub-market-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-remote-work-hub-market-analyzer",
                "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/trovevault~remote-work-hub-market-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-remote-work-hub-market-analyzer",
                "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/trovevault~remote-work-hub-market-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-remote-work-hub-market-analyzer",
                "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",
                "required": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Cities to analyze for remote-work market opportunity. Use city and country when possible, for example `Lisbon, Portugal`, `Porto, Portugal`, or `Barcelona, Spain`. The actor returns one decision row per location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "buyerProfile": {
                        "title": "Buyer Profile",
                        "enum": [
                            "coworking_operator",
                            "coliving_operator",
                            "tourism_board",
                            "real_estate_developer",
                            "remote_team"
                        ],
                        "type": "string",
                        "description": "The business profile behind the analysis. A coworking operator sees a different opportunity score than a tourism board, coliving operator, real estate developer, or remote team.",
                        "default": "coworking_operator"
                    },
                    "benchmarkAgainst": {
                        "title": "Benchmark Against",
                        "type": "array",
                        "description": "Cities to use as a comparison set. This makes the output relative, for example whether Lisbon is above or below Porto on coworking supply, workspace density, community momentum, and opportunity score. Leave blank for actor-owned default benchmarks.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append results to, in addition to the default run dataset. Leave blank for normal runs."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "Optional external run or client batch ID. When supplied, it is copied to each output row."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
