# Gutefrage.de Q\&A Scraper (`barrierefix/gutefrage-scraper`)

Scrape questions, answers, and metadata from Gutefrage.net - Germany's largest Q\&A platform with 27M+ questions and 100M+ answers.

- **URL**: https://apify.com/barrierefix/gutefrage-scraper.md
- **Developed by:** [BarriereFix](https://apify.com/barrierefix) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

# README

## Gutefrage.de Scraper - German Q\&A Data Extractor

Extract questions and answers from **Gutefrage.net** (Gutefrage.de) - Germany's largest question-and-answer community with 27 million+ questions and 100 million+ answers.

### What does this Gutefrage scraper do?

- **Search Gutefrage questions**: Find German Q\&A data using keywords (e.g., "Python programmieren", "ChatGPT tutorial")
- **Extract German question data**: Get full question text, author info, upvotes, timestamps, tags, and best answer
- **Scrape Gutefrage answers**: Collect all answers with author details, timestamps, and vote counts
- **Browse by topics**: Explore specific categories/tags on Gutefrage.net
- **Bulk question scraping**: Scrape multiple questions at once (up to 50 per search query)

Perfect for German market research, SEO keyword research, content strategy, and German NLP/AI training datasets.

### Use cases for Gutefrage data

- **German market research**: Discover what German-speaking users ask about your industry, product, or service
- **SEO keyword research**: Find real German search queries and long-tail keywords people use
- **Content strategy**: Identify trending topics and frequently asked questions in German
- **German NLP datasets**: Build question-answering datasets for German language AI models
- **Competitor monitoring**: Track questions and discussions about competing brands
- **Community insights**: Analyze sentiment and common pain points in German communities
- **Academic research**: Study German online discourse and community behavior

### Input configuration

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| **searchMode** | String | How to find questions: `search`, `tag`, or `url` | `search` |
| **searchQueries** | Array | Search terms to find questions (e.g., "python lernen", "was ist KI") | `["python"]` |
| **tags** | Array | Gutefrage.net tags to browse (e.g., "programmierung", "gesundheit") | `[]` |
| **questionUrls** | Array | Direct Gutefrage question URLs to scrape | `[]` |
| **maxQuestionsPerQuery** | Number | Maximum questions per search query or tag (1-50) | `50` |
| **includeAnswers** | Boolean | Extract all answers for each question | `true` |
| **includeComments** | Boolean | Include comments on answers (increases data volume) | `false` |

#### Search modes explained

**1. Search mode** (`searchMode: "search"`) - **Recommended**

- Uses Gutefrage's real search engine to find relevant questions
- Example: `searchQueries: ["python programmieren", "javascript fehler", "chatgpt deutsch"]`
- Best for: Finding questions matching specific keywords or phrases
- Returns: Most relevant questions based on Gutefrage's search algorithm

**2. Tag mode** (`searchMode: "tag"`)

- Browse questions by Gutefrage.net category tags
- Example: `tags: ["python", "programmierung", "html", "css"]`
- Best for: Exploring all questions in a specific topic category
- Returns: Latest questions in each tag, chronologically

**3. URL mode** (`searchMode: "url"`)

- Scrape specific Gutefrage question pages directly
- Example: `questionUrls: ["https://www.gutefrage.net/frage/was-ist-python"]`
- Best for: Extracting data from known question URLs
- Returns: Exact questions you specify

### Output - Gutefrage question data format

Each record represents one complete Gutefrage question with all answers:

```json
{
  "questionId": "was-ist-python",
  "questionTitle": "Was ist Python?",
  "questionText": "Ich habe viel über Python gehört...",
  "questionAuthor": "techuser123",
  "questionAuthorUrl": "https://www.gutefrage.net/nutzer/techuser123",
  "questionUrl": "https://www.gutefrage.net/frage/was-ist-python",
  "questionCreatedAt": "2024-01-15T10:30:00+01:00",
  "questionModifiedAt": "2024-01-15T10:30:00+01:00",
  "questionUpvoteCount": 5,
  "questionAnswerCount": 3,
  "questionTags": ["Python", "Programmierung", "Informatik"],

  "bestAnswerId": "123456789",
  "bestAnswerText": "Python ist eine Programmiersprache...",

  "answers": [
    {
      "answerId": "123456789",
      "answerText": "Python ist eine Programmiersprache...",
      "answerAuthor": "PythonExpert",
      "answerAuthorUrl": "https://www.gutefrage.net/nutzer/PythonExpert",
      "answerUrl": "https://www.gutefrage.net/frage/was-ist-python#answer-123456789",
      "answerCreatedAt": "2024-01-15T11:00:00+01:00",
      "answerUpvoteCount": 10,
      "answerCommentCount": 2,
      "isAcceptedAnswer": true
    }
  ],

  "scrapedAt": "2025-10-27T12:00:00Z",
  "actorRunId": "abc123"
}
```

**Data structure benefits:**

- ✅ **Flat structure**: One question = one record (perfect for databases and spreadsheets)
- ✅ **Best answer included**: Get the accepted answer text directly for quick analysis
- ✅ **Nested answers array**: All related answers grouped with the question
- ✅ **Integration-ready**: Works seamlessly with Excel, Google Sheets, n8n, Zapier, Make, Airtable
- ✅ **Consistent schema**: Every record has the same fields (no undefined values)
- ✅ **Export formats**: JSON, CSV, Excel, XML - choose your preferred format

### Example use cases with input configurations

#### 1. German SEO keyword research - Python questions

```json
{
  "searchMode": "search",
  "searchQueries": ["was ist python", "python programmieren lernen"],
  "maxQuestionsPerQuery": 20,
  "includeAnswers": true
}
```

**Output:** 40 real German questions about Python with all answers
**Use for:** SEO content ideas, FAQ sections, German keyword research

#### 2. Market research - AI and ChatGPT questions in German

```json
{
  "searchMode": "search",
  "searchQueries": ["chatgpt deutsch", "ki assistant", "künstliche intelligenz"],
  "maxQuestionsPerQuery": 20,
  "includeAnswers": true
}
```

**Output:** 60 questions Germans ask about AI and ChatGPT
**Use for:** Understanding German market needs, content planning, product positioning

#### 3. Browse programming category - Tag mode

```json
{
  "searchMode": "tag",
  "tags": ["python", "javascript", "programmierung"],
  "maxQuestionsPerQuery": 20,
  "includeAnswers": true
}
```

**Output:** 60 latest programming questions from Gutefrage
**Use for:** Community monitoring, topic trends, user pain points

#### 4. Specific question deep-dive - URL mode

```json
{
  "searchMode": "url",
  "questionUrls": [
    "https://www.gutefrage.net/frage/was-ist-python",
    "https://www.gutefrage.net/frage/wie-python-lernen"
  ],
  "includeAnswers": true,
  "includeComments": true
}
```

**Output:** 2 complete question threads with answers and comments
**Use for:** Detailed analysis, sentiment research, answer quality assessment

### Pricing

**Pay-per-event pricing model**: $0.001-0.005 per Gutefrage question scraped

**Example costs:**

- 20 questions (default) = $0.02-0.10
- 100 questions = $0.10-0.50
- 500 questions = $0.50-2.50

Very affordable for German market research and SEO keyword analysis.

### Integration with automation tools

**Seamless integration with:**

- ✅ **n8n**: Automate German content workflows
- ✅ **Zapier**: Trigger actions based on Gutefrage data
- ✅ **Make** (Integromat): Build German market research scenarios
- ✅ **Google Sheets**: Export to spreadsheets for analysis
- ✅ **Airtable**: Store Gutefrage questions in databases
- ✅ **Power BI / Tableau**: Visualize German Q\&A trends
- ✅ **Python/Node.js**: API access for custom integrations

Export formats: JSON, CSV, Excel, XML, RSS

### Technical implementation

- **Scraping method**: Lightweight HTTP requests with Cheerio (no browser needed)
- **Data source**: Extracts JSON-LD structured data (Schema.org QAPage format)
- **Speed**: ~1 second per question (including answers)
- **Rate limiting**: Built-in delays to respect Gutefrage.net servers
- **Error handling**: Continues scraping even if individual questions fail
- **Proxies**: Not required (public data, no blocking)
- **Language**: German content extraction optimized

### Frequently Asked Questions (FAQ)

**Q: What's the difference between search mode and tag mode?**
A: Search mode uses Gutefrage's search engine (best for specific queries like "was ist python"). Tag mode browses categories chronologically (best for exploring topics).

**Q: Can I search in English or do I need German keywords?**
A: Gutefrage is a German site, so German search queries work best. The scraper extracts German-language content.

**Q: How do I find Gutefrage tags to scrape?**
A: Visit Gutefrage.net, browse topics, and check the URL. Example: `https://www.gutefrage.net/tag/python/1` → tag is `"python"`.

**Q: Does this scrape user profiles?**
A: No, only questions and answers. User names and profile URLs are included in question/answer data.

**Q: Can I get best answers only?**
A: Yes! The `bestAnswerText` field contains the accepted answer. Filter by this field in your export.

**Q: Is this legal and allowed by Gutefrage?**
A: The scraper accesses public data respectfully with rate limiting. Review Gutefrage.net's terms of service for your specific use case.

**Q: Can I scrape real-time / fresh questions?**
A: Yes! Search and tag modes show the latest questions. Run the actor regularly to monitor new content.

**Q: How do I export to Google Sheets or Excel?**
A: After scraping, click "Export" in the dataset view and choose CSV/Excel format. Import into your tool.

**Q: Can I schedule automatic scraping?**
A: Yes! Use Apify's scheduler to run the actor daily/weekly and send results to your integrations.

***

### 🔗 Explore More of Our Actors

#### 🍳 German Content & Lifestyle

| Actor | Description |
|-------|-------------|
| [Chefkoch Scraper](https://apify.com/barrierefix/chefkoch-scraper) | Extract recipes and cooking instructions from Chefkoch.de |
| [Recalls Safety Aggregator](https://apify.com/barrierefix/recalls-safety-aggregator) | Aggregate product recalls and safety alerts |

#### 💬 Social Media & Community

| Actor | Description |
|-------|-------------|
| [Reddit Scraper Pro](https://apify.com/barrierefix/reddit-scraper-pro) | Monitor subreddits and track keywords with sentiment analysis |
| [Discord Scraper Pro](https://apify.com/barrierefix/discord-scraper-pro) | Extract Discord messages and chat history for community insights |

#### 🏢 Business Intelligence

| Actor | Description |
|-------|-------------|
| [Northdata Scraper](https://apify.com/barrierefix/northdata-scraper) | Extract German company data from Northdata for business research |
| [Crunchbase Scraper](https://apify.com/barrierefix/crunchbase-scraper) | Extract company data and funding information for business intelligence |

***

### Keywords for SEO

Gutefrage scraper, Gutefrage.de data extraction, German Q\&A scraper, extract Gutefrage questions, Gutefrage.net API alternative, German market research tool, German SEO keyword research, scrape German questions and answers, Gutefrage data export, German community insights, Gutefrage automation, German content research, Frage und Antwort scraper

# Actor input Schema

## `searchMode` (type: `string`):

How to find questions to scrape

## `searchQueries` (type: `array`):

Search queries to find questions. Example: 'was ist python', 'javascript fehler', 'chatgpt tutorial'

## `tags` (type: `array`):

Tags/topics to scrape questions from. Example: 'python', 'javascript', 'programmierung'. Each tag will fetch questions from gutefrage.net/tag/\[tag]

## `questionUrls` (type: `array`):

Direct question URLs to scrape. Format: https://www.gutefrage.net/frage/your-question-slug

## `maxQuestionsPerQuery` (type: `integer`):

Maximum number of questions to scrape per search query or tag. Default: 20. Max: 50.

## `includeAnswers` (type: `boolean`):

Fetch all answers for each question. Recommended: keep enabled unless you only need question metadata.

## `includeComments` (type: `boolean`):

Fetch comments on answers. ⚠️ Increases data size significantly. Only enable if you need comment data.

## Actor input object example

```json
{
  "searchMode": "search",
  "searchQueries": [
    "was ist python",
    "wie python lernen",
    "chatgpt deutsch"
  ],
  "tags": [],
  "questionUrls": [],
  "maxQuestionsPerQuery": 20,
  "includeAnswers": true,
  "includeComments": false
}
```

# 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 = {
    "searchQueries": [
        "was ist python",
        "wie python lernen",
        "chatgpt deutsch"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("barrierefix/gutefrage-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 = { "searchQueries": [
        "was ist python",
        "wie python lernen",
        "chatgpt deutsch",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("barrierefix/gutefrage-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 '{
  "searchQueries": [
    "was ist python",
    "wie python lernen",
    "chatgpt deutsch"
  ]
}' |
apify call barrierefix/gutefrage-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gutefrage.de Q&A Scraper",
        "description": "Scrape questions, answers, and metadata from Gutefrage.net - Germany's largest Q&A platform with 27M+ questions and 100M+ answers.",
        "version": "1.0",
        "x-build-id": "ymfsqLCJNQBY9ppGc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/barrierefix~gutefrage-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-barrierefix-gutefrage-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/barrierefix~gutefrage-scraper/runs": {
            "post": {
                "operationId": "runs-sync-barrierefix-gutefrage-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/barrierefix~gutefrage-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-barrierefix-gutefrage-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": {
                    "searchMode": {
                        "title": "Search Mode",
                        "enum": [
                            "search",
                            "tag",
                            "url"
                        ],
                        "type": "string",
                        "description": "How to find questions to scrape",
                        "default": "search"
                    },
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Search queries to find questions. Example: 'was ist python', 'javascript fehler', 'chatgpt tutorial'",
                        "default": [
                            "was ist python"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "tags": {
                        "title": "Tags",
                        "type": "array",
                        "description": "Tags/topics to scrape questions from. Example: 'python', 'javascript', 'programmierung'. Each tag will fetch questions from gutefrage.net/tag/[tag]",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "questionUrls": {
                        "title": "Question URLs",
                        "type": "array",
                        "description": "Direct question URLs to scrape. Format: https://www.gutefrage.net/frage/your-question-slug",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxQuestionsPerQuery": {
                        "title": "Max Questions Per Query/Tag",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of questions to scrape per search query or tag. Default: 20. Max: 50.",
                        "default": 20
                    },
                    "includeAnswers": {
                        "title": "Include Answers",
                        "type": "boolean",
                        "description": "Fetch all answers for each question. Recommended: keep enabled unless you only need question metadata.",
                        "default": true
                    },
                    "includeComments": {
                        "title": "Include Comments",
                        "type": "boolean",
                        "description": "Fetch comments on answers. ⚠️ Increases data size significantly. Only enable if you need comment data.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
