# German Football Results & Tables (`trovevault/german-football-results-tables`) Actor

Extracts German football matches, scores, scorers, standings, teams, points, and rounds. Export data, run via API, schedule and monitor runs, or integrate with other tools.

- **URL**: https://apify.com/trovevault/german-football-results-tables.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** News, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 match or league standings

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

### What does German Football Results & Tables do?

German Football Results & Tables returns structured **German football match results and league tables** for selected men's and women's competitions. It focuses on German domestic football only: Bundesliga, 2. Bundesliga, 3. Liga, DFB-Pokal, Frauen-Bundesliga, and 2. Frauen-Bundesliga.

The actor is useful as a lightweight German football API alternative when you need clean rows for dashboards, spreadsheets, scheduled updates, reporting workflows, or downstream data pipelines.

### Why use German Football Results & Tables?

Use this actor when you need German football data in a consistent dataset instead of manually checking separate competition pages. You can select several competitions in one run, limit match output to a specific round or matchday, and return matches and current standings as two separate output tables.

Main capabilities:

- Retrieve matches, dates, teams, scores, status, and winners.
- Retrieve standings for league competitions with position, points, record, and goals.
- Compare men's and women's German football competitions in one normalized format.
- Schedule matchday runs on Apify and export data through the API.
- Append results into an existing Apify dataset with `datasetId`.
- Add your own workflow identifier with `runId`.

### What data can it extract?

| Field | Type | Description |
|---|---:|---|
| `leagueName` | string | German competition name |
| `competitionType` | string | `league` or `cup` |
| `competitionGender` | string | `men` or `women` |
| `season` | number | Season start year |
| `round` | number | Matchday or cup round when available |
| `matchDate` | string | Match date in ISO 8601 format |
| `homeTeam`, `awayTeam` | string | Teams for match rows |
| `homeScore`, `awayScore` | number | Score when available |
| `winner` | string | `home`, `away`, `draw`, or empty |
| `position`, `teamName`, `points` | number/string | Standing row fields |
| `played`, `won`, `drawn`, `lost` | number | League record |
| `goalsFor`, `goalsAgainst`, `goalDifference` | number | League-table goal fields |

### Supported German competitions

The dropdown currently supports:

- Bundesliga
- 2. Bundesliga
- 3. Liga
- DFB-Pokal
- Frauen-Bundesliga
- 2. Frauen-Bundesliga

DFB-Pokal is a cup competition, so it returns match rows only. Standings apply to league competitions.

### Use cases

- Build German football dashboards and matchday trackers.
- Keep a spreadsheet of Bundesliga and Frauen-Bundesliga results.
- Feed editorial tools with structured score and standings data.
- Compare men's and women's German domestic competitions.
- Schedule daily or matchday updates through Apify.
- Combine this dataset with your own club, attendance, betting, or media workflows where legally permitted.

### How to use it

1. Open the actor input tab.
2. Choose one or more German competitions from the Competitions dropdown.
3. Set the season start year, for example `2025` for 2025/2026.
4. Optionally set Round to retrieve only one matchday or cup round.
5. Keep Include Matches enabled for fixtures and scores.
6. Keep Include Standings enabled when you want league tables.
7. Run the actor and download the Matches and Standings tables as JSON, CSV, Excel, XML, or HTML.

### Input

See the input tab for full configuration options.

Example input:

```json
{
  "leagues": ["bundesliga", "frauen-bundesliga"],
  "season": 2025,
  "round": 1,
  "includeMatches": true,
  "includeStandings": true,
  "maxMatches": 20
}
````

For scheduled matchday updates, set `round` and keep `maxMatches` low. For full-season match exports, leave `round` blank and raise `maxMatches`. Standings rows represent the current season table available for that competition, not a historical table for the selected round.

### Output

The actor creates two output tables: **Matches** and **Standings**. You can download each dataset in various formats such as JSON, HTML, CSV, or Excel.

Example output:

```json
[
  {
    "leagueName": "Bundesliga",
    "competitionType": "league",
    "competitionGender": "men",
    "season": 2025,
    "round": 1,
    "matchDate": "2025-08-22T18:30:00.000Z",
    "status": "finished",
    "homeTeam": "FC Bayern München",
    "awayTeam": "RB Leipzig",
    "homeScore": 6,
    "awayScore": 0,
    "winner": "home"
  },
  {
    "leagueName": "Bundesliga",
    "competitionType": "league",
    "competitionGender": "men",
    "season": 2025,
    "position": 1,
    "teamName": "FC Bayern München",
    "played": 31,
    "won": 26,
    "drawn": 4,
    "lost": 1,
    "goalsFor": 113,
    "goalsAgainst": 32,
    "goalDifference": 81,
    "points": 82
  }
]
```

### API usage example

```bash
curl "https://api.apify.com/v2/acts/trovevault~german-football-results-tables/runs?waitForFinish=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "leagues": ["bundesliga", "2-bundesliga"],
    "season": 2025,
    "round": 1,
    "includeMatches": true,
    "includeStandings": true,
    "maxMatches": 20
  }'
```

### Limitations

This actor covers German domestic competitions only. It does not include Champions League, Europa League, national-team fixtures, non-German leagues, or player-level scorer feeds.

The underlying data is community-maintained, so coverage can vary by competition, season, and timing. Recent high-quality German competitions are the best fit. Cup competitions do not produce standings.

### FAQ

#### Does this actor include Champions League?

No. The scope is German domestic football only.

#### Can I select multiple leagues?

Yes. The Competitions field is a multi-select dropdown.

#### Does DFB-Pokal return standings?

No. DFB-Pokal is a cup competition, so it returns matches only.

#### Which season format should I use?

Use the season start year. For example, `2025` means the 2025/2026 season for most competitions.

#### Can I get only one round?

Yes. Set Round to a matchday or cup round number.

#### Does the actor include scorers?

No. This actor is standardized around match results and standings only.

#### Is the output suitable for spreadsheets?

Yes. Matches and standings are separate flat tables that export cleanly to CSV or Excel.

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

Yes. Fill `datasetId` to append rows to another Apify dataset in addition to the default run datasets. When both matches and standings are appended to this external dataset, the actor adds `entityType` so downstream workflows can distinguish `match` and `standing` rows.

### Troubleshooting

If a run returns fewer rows than expected, check the selected season and round first. Some competitions may not have data for every historical season, and cup round numbering can differ from league matchdays. If standings do not match the selected round, that is expected: tables are current season standings.

If standings are missing for DFB-Pokal, that is expected because cups do not have league tables.

For bugs, missing competitions, or output issues, use the Issues tab on the actor page.

### Related actors

You may also want actors for football analytics, sports monitoring, or other TroveVault sports datasets as they become available.

### Changelog

#### 0.1

Initial version with German domestic football matches and league tables.

# Actor input Schema

## `leagues` (type: `array`):

German football competitions to retrieve. The actor fetches fixtures, scores, and standings for each selected competition, then returns a normalized dataset across men's and women's football. Select one league for a compact run or several competitions to compare Bundesliga, 2. Bundesliga, 3. Liga, DFB-Pokal, Frauen-Bundesliga, and 2. Frauen-Bundesliga in one dataset. Standings apply to league competitions only; DFB-Pokal returns match rows.

## `season` (type: `integer`):

Season start year to retrieve. German football seasons use the first year of the season, so 2025 means the 2025/2026 season for most competitions. Use a recent year such as 2024 or 2025 for the most complete data. Older seasons may be less complete depending on community-maintained records.

## `round` (type: `integer`):

Optional round or matchday number to retrieve for match rows. When filled, the actor returns only that matchday or cup round, for example 1 for opening matchday or an early DFB-Pokal round. Leave blank to retrieve all matches in the selected season. Standings are season tables and are not filtered to a historical round.

## `includeMatches` (type: `boolean`):

Whether to return match rows with teams, dates, scores, status, winner, and round. Disable this only when you need league tables without fixtures. Recommended: keep enabled for most workflows because match rows are the primary result feed.

## `includeStandings` (type: `boolean`):

Whether to return current season standings rows for league competitions. The actor ignores standings for DFB-Pokal because cup competitions do not have a league table, and the Round input does not rewind tables to a historical matchday. Disable this to reduce output size when you only need fixtures and results.

## `maxMatches` (type: `integer`):

Maximum match rows to return for each selected competition after round filtering. Higher values give a fuller season dataset but produce more rows and take longer. Use 10 to 20 for testing or matchday updates, and 500 for full league seasons and cup runs.

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

ID of an existing Apify dataset to append results to, in addition to the default run dataset. Leave blank to use only the default run dataset. Use this when chaining scheduled football updates into a long-lived database or dashboard dataset.

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

ID of an existing Apify actor run or workflow step to associate with output rows. The actor copies this value into each row when provided, which helps connect German football results to pipeline runs. Leave blank for standalone runs.

## Actor input object example

```json
{
  "leagues": [
    "bundesliga"
  ],
  "season": 2025,
  "includeMatches": true,
  "includeStandings": true,
  "maxMatches": 20
}
```

# Actor output Schema

## `matches` (type: `string`):

No description

## `standings` (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 = {
    "leagues": [
        "bundesliga"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/german-football-results-tables").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 = { "leagues": ["bundesliga"] }

# Run the Actor and wait for it to finish
run = client.actor("trovevault/german-football-results-tables").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 '{
  "leagues": [
    "bundesliga"
  ]
}' |
apify call trovevault/german-football-results-tables --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=trovevault/german-football-results-tables",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "German Football Results & Tables",
        "description": "Extracts German football matches, scores, scorers, standings, teams, points, and rounds. Export data, run via API, schedule and monitor runs, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "jcHbCHOTfIRjUKwxa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~german-football-results-tables/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-german-football-results-tables",
                "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~german-football-results-tables/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-german-football-results-tables",
                "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~german-football-results-tables/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-german-football-results-tables",
                "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": [
                    "leagues"
                ],
                "properties": {
                    "leagues": {
                        "title": "Competitions",
                        "type": "array",
                        "description": "German football competitions to retrieve. The actor fetches fixtures, scores, and standings for each selected competition, then returns a normalized dataset across men's and women's football. Select one league for a compact run or several competitions to compare Bundesliga, 2. Bundesliga, 3. Liga, DFB-Pokal, Frauen-Bundesliga, and 2. Frauen-Bundesliga in one dataset. Standings apply to league competitions only; DFB-Pokal returns match rows.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "bundesliga",
                                "2-bundesliga",
                                "3-liga",
                                "dfb-pokal",
                                "frauen-bundesliga",
                                "2-frauen-bundesliga"
                            ],
                            "enumTitles": [
                                "Bundesliga",
                                "2. Bundesliga",
                                "3. Liga",
                                "DFB-Pokal",
                                "Frauen-Bundesliga",
                                "2. Frauen-Bundesliga"
                            ]
                        }
                    },
                    "season": {
                        "title": "Season Start Year",
                        "minimum": 2003,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Season start year to retrieve. German football seasons use the first year of the season, so 2025 means the 2025/2026 season for most competitions. Use a recent year such as 2024 or 2025 for the most complete data. Older seasons may be less complete depending on community-maintained records.",
                        "default": 2025
                    },
                    "round": {
                        "title": "Round",
                        "minimum": 1,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Optional round or matchday number to retrieve for match rows. When filled, the actor returns only that matchday or cup round, for example 1 for opening matchday or an early DFB-Pokal round. Leave blank to retrieve all matches in the selected season. Standings are season tables and are not filtered to a historical round."
                    },
                    "includeMatches": {
                        "title": "Include Matches",
                        "type": "boolean",
                        "description": "Whether to return match rows with teams, dates, scores, status, winner, and round. Disable this only when you need league tables without fixtures. Recommended: keep enabled for most workflows because match rows are the primary result feed.",
                        "default": true
                    },
                    "includeStandings": {
                        "title": "Include Standings",
                        "type": "boolean",
                        "description": "Whether to return current season standings rows for league competitions. The actor ignores standings for DFB-Pokal because cup competitions do not have a league table, and the Round input does not rewind tables to a historical matchday. Disable this to reduce output size when you only need fixtures and results.",
                        "default": true
                    },
                    "maxMatches": {
                        "title": "Max Matches Per Competition",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum match rows to return for each selected competition after round filtering. Higher values give a fuller season dataset but produce more rows and take longer. Use 10 to 20 for testing or matchday updates, and 500 for full league seasons and cup runs.",
                        "default": 20
                    },
                    "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 to use only the default run dataset. Use this when chaining scheduled football updates into a long-lived database or dashboard dataset."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify actor run or workflow step to associate with output rows. The actor copies this value into each row when provided, which helps connect German football results to pipeline runs. Leave blank for standalone runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
