# GTEx Gene Expression Scraper (`parseforge/gtex-gene-expression-scraper`) Actor

Profile any gene across human tissues with the GTEx Portal. Resolve a symbol like BRCA1, TP53, or EGFR to its gencode ID, then pull median expression for all 54 tissues with tissue name, median TPM, UBERON ontology ID, and dataset release. Great for target research and expression analysis.

- **URL**: https://apify.com/parseforge/gtex-gene-expression-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧬 GTEx Gene Expression Scraper

> 🚀 **Turn any gene symbol into a full tissue expression profile.** Resolve BRCA1, TP53, or EGFR to its GTEx gencode ID and pull median expression across all 54 human tissues, each as one clean record.

> 🕒 **Last updated:** 2026-06-05 · **📊 13 fields** per record · keyless public API · 54 GTEx tissues per gene

GTEx (the Genotype-Tissue Expression project) is a reference resource that measures gene expression across dozens of human tissues from hundreds of donors. This Actor queries the GTEx Portal API, resolves each gene symbol to the gencode ID used by the current expression release, and returns one record per tissue with the median expression value.

Coverage spans every tissue site detail in the GTEx v10 release, from adipose and artery to brain subregions, whole blood, and reproductive tissues. You can look up a single gene or paste a batch of symbols, and each gene expands into its full tissue profile so you can compare expression side by side.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Genomics and biology researchers | Build a tissue expression table for a gene panel |
| Bioinformaticians and data scientists | Map gene symbols to gencode IDs and median TPM |
| Drug discovery and target teams | Check where a candidate target is expressed |
| Educators and students | Illustrate tissue-specific expression patterns |

### 📋 What the GTEx Gene Expression Scraper does

- Resolves gene symbols (for example BRCA1, TP53, EGFR) to the GTEx gencode ID for the current release.
- Fetches median gene expression for every GTEx tissue in one pass.
- Returns one record per gene and tissue, with median value and unit.
- Carries the GTEx tissue ontology ID and dataset version on every row.
- Handles a batch of gene symbols in a single run.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `geneSymbols` | array | yes | One or more HGNC gene symbols to resolve and profile. |
| `maxItems` | integer | no | Cap on how many records are produced. Free plan is limited to 10. |

Provide at least one gene symbol. Each gene produces one record per GTEx tissue.

```json
{
  "geneSymbols": ["BRCA1", "TP53", "EGFR"],
  "maxItems": 10
}
````

```json
{
  "geneSymbols": ["TP53"],
  "maxItems": 54
}
```

> ⚠️ **Good to Know:** Symbols are resolved against the gencode version that matches the GTEx expression release, so the gencode ID returned may differ from a generic Ensembl lookup. A symbol that GTEx does not carry is reported as an error row rather than a faked record. Median values are tissue medians in TPM as published by GTEx.

### 📊 Output

Each record is one gene measured in one tissue.

| 🏷 Field | Description |
|---|---|
| 🧬 `geneSymbol` | HGNC gene symbol |
| 🆔 `gencodeId` | GTEx gencode ID (release matched) |
| 🔢 `entrezGeneId` | NCBI Entrez gene ID |
| 🧫 `geneType` | Gene biotype, for example protein coding |
| 📍 `chromosome` | Chromosome of the gene |
| 🩻 `tissueSiteDetailId` | GTEx tissue site detail ID |
| 🧭 `tissue` | Human readable tissue name |
| 📊 `median` | Median expression value in the tissue |
| 📐 `unit` | Expression unit, TPM |
| 🔖 `ontologyId` | UBERON ontology ID for the tissue |
| 🗂 `datasetId` | GTEx dataset release, for example gtex\_v10 |
| 🔗 `url` | GTEx Portal gene page |
| 🕒 `scrapedAt` | Timestamp of collection |
| ❌ `error` | Error message, null on success |

Real sample records from a live run:

```json
{
  "geneSymbol": "BRCA1",
  "gencodeId": "ENSG00000012048.23",
  "entrezGeneId": 672,
  "geneType": "protein coding",
  "chromosome": "chr17",
  "tissueSiteDetailId": "Adipose_Subcutaneous",
  "tissue": "Adipose Subcutaneous",
  "median": 1.44629,
  "unit": "TPM",
  "ontologyId": "UBERON:0002190",
  "datasetId": "gtex_v10",
  "url": "https://gtexportal.org/home/gene/BRCA1",
  "scrapedAt": "2026-06-05T17:41:20.517Z",
  "error": null
}
```

```json
{
  "geneSymbol": "BRCA1",
  "gencodeId": "ENSG00000012048.23",
  "entrezGeneId": 672,
  "geneType": "protein coding",
  "chromosome": "chr17",
  "tissueSiteDetailId": "Adipose_Visceral_Omentum",
  "tissue": "Adipose Visceral Omentum",
  "median": 1.09296,
  "unit": "TPM",
  "ontologyId": "UBERON:0010414",
  "datasetId": "gtex_v10",
  "url": "https://gtexportal.org/home/gene/BRCA1",
  "scrapedAt": "2026-06-05T17:41:20.595Z",
  "error": null
}
```

```json
{
  "geneSymbol": "BRCA1",
  "gencodeId": "ENSG00000012048.23",
  "entrezGeneId": 672,
  "geneType": "protein coding",
  "chromosome": "chr17",
  "tissueSiteDetailId": "Adrenal_Gland",
  "tissue": "Adrenal Gland",
  "median": 0.903838,
  "unit": "TPM",
  "ontologyId": "UBERON:0002369",
  "datasetId": "gtex_v10",
  "url": "https://gtexportal.org/home/gene/BRCA1",
  "scrapedAt": "2026-06-05T17:41:20.627Z",
  "error": null
}
```

### ✨ Why choose this Actor

- One tidy row per tissue instead of a nested expression payload.
- Symbols are matched to the gencode ID that the expression release actually uses.
- Carries ontology IDs so you can join to UBERON and other tissue vocabularies.
- Keyless public source, so no account or token juggling on the source side.
- Null is honest, never invented, so your downstream joins stay clean.

### 📈 How it compares to alternatives

| Approach | Coverage | Tissue mapping | Setup |
|---|---|---|---|
| This Actor | All GTEx tissues per gene | Tissue ID, name, and UBERON ontology | Paste symbols and run |
| Raw GTEx API | Available but needs ID resolution first | Tissue ID only | Write your own resolver |
| Manual portal lookup | One gene at a time | Read off the chart | Slow and manual |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the GTEx Gene Expression Scraper.
3. Enter one or more gene symbols in `geneSymbols`.
4. Set `maxItems` if you want to cap the run, then start the Actor.
5. Collect your results from the dataset once the run finishes.

### 💼 Business use cases

#### Drug target research

| Goal | How this helps |
|---|---|
| Check target tissue selectivity | Compare median expression across all tissues for a gene |
| Flag off-target tissues | Spot tissues where a target is highly expressed |

#### Bioinformatics reference data

| Goal | How this helps |
|---|---|
| Build an expression matrix | Pull gene by tissue medians for a panel |
| Standardize tissue labels | Use the UBERON ontology IDs to join datasets |

#### Diagnostics and biomarker work

| Goal | How this helps |
|---|---|
| Profile candidate markers | Read tissue specific expression at a glance |
| Compare gene families | Run a batch of related symbols together |

#### Education and training

| Goal | How this helps |
|---|---|
| Teach expression concepts | Show how one gene varies across tissues |
| Seed classroom datasets | Generate clean tables for exercises |

### 🔌 Automating GTEx Gene Expression Scraper

Connect runs to the tools your team already uses:

- **Make** and **Zapier** to trigger runs and route records into other apps.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub Actions** to schedule recurring pulls.
- **Google Drive** to archive each run output for your team.

### 🌟 Beyond business use cases

- **Research:** assemble a tissue expression table for a literature review.
- **Personal:** explore where a gene you read about is active in the body.
- **Non-profit:** support patient education materials with reference expression facts.
- **Experimentation:** prototype a tool that ranks tissues by expression for any gene.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask it to rank tissues by expression, group genes by pattern, or summarize where a target is active.

### ❓ Frequently Asked Questions

**Is the GTEx Portal free to query?**
Yes, the GTEx Portal API is a keyless public resource. This Actor adds symbol resolution and clean per tissue output on top.

**What can I put in the gene list?**
Standard HGNC gene symbols such as BRCA1, TP53, or EGFR. Each symbol is resolved and expanded into its tissue profile.

**How many records does one gene produce?**
One record per GTEx tissue. In the current release that is 54 tissues per gene.

**Why does the gencode ID differ from other databases?**
GTEx expression is keyed to a specific gencode version. The Actor resolves symbols against that version so the ID matches the expression data.

**What does median mean here?**
It is the median expression across donor samples for that gene in that tissue, in TPM, as published by GTEx.

**Why is a record sometimes an error row?**
If a symbol is not carried by GTEx or has no expression data, the Actor returns an error row instead of inventing values.

**Can I run many genes at once?**
Yes, paste a batch of symbols and each one expands into its own tissue profile in the same run.

**What is the ontology ID for?**
It is the UBERON tissue identifier, useful for joining GTEx tissues to other ontologies and datasets.

**Which release does the data come from?**
The dataset version is on every row in the `datasetId` field, for example gtex\_v10.

**How many records can I get?**
Free plan runs are limited to 10. Paid plans can collect up to 1,000,000.

### 🔌 Integrate with any app

Every run writes to a structured dataset you can pull through the Apify API or connect to your stack with the integrations above.

### 🔗 Recommended Actors

- [MyChem.info Drug Annotation Scraper](https://apify.com/parseforge) for curated drug and compound data.
- [Reactome Pathways Scraper](https://apify.com/parseforge) for biological pathway data.
- [Orphanet Rare Diseases Scraper](https://apify.com/parseforge) for rare disease reference data.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with GTEx or the GTEx Portal. Only publicly available data collected.

# Actor input Schema

## `geneSymbols` (type: `array`):

One or more HGNC gene symbols (for example BRCA1, TP53, EGFR). Each symbol is resolved to its GTEx gencode ID, then median expression is collected across every tissue.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "geneSymbols": [
    "BRCA1",
    "TP53",
    "EGFR"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "geneSymbols": [
        "BRCA1",
        "TP53",
        "EGFR"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/gtex-gene-expression-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 = {
    "geneSymbols": [
        "BRCA1",
        "TP53",
        "EGFR",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/gtex-gene-expression-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 '{
  "geneSymbols": [
    "BRCA1",
    "TP53",
    "EGFR"
  ],
  "maxItems": 10
}' |
apify call parseforge/gtex-gene-expression-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GTEx Gene Expression Scraper",
        "description": "Profile any gene across human tissues with the GTEx Portal. Resolve a symbol like BRCA1, TP53, or EGFR to its gencode ID, then pull median expression for all 54 tissues with tissue name, median TPM, UBERON ontology ID, and dataset release. Great for target research and expression analysis.",
        "version": "0.1",
        "x-build-id": "HWOgWacUUALauLwUp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~gtex-gene-expression-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-gtex-gene-expression-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/parseforge~gtex-gene-expression-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-gtex-gene-expression-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/parseforge~gtex-gene-expression-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-gtex-gene-expression-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": {
                    "geneSymbols": {
                        "title": "Gene Symbols",
                        "type": "array",
                        "description": "One or more HGNC gene symbols (for example BRCA1, TP53, EGFR). Each symbol is resolved to its GTEx gencode ID, then median expression is collected across every tissue.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```