# Date Format Normalizer (`avqelle/date-format-normalizer`) Actor

Normalize messy date strings into clean ISO 8601 or custom date formats. Handles common date formats, relative dates, multilingual inputs, timezone conversion, and returns clear error results for unparseable dates.

- **URL**: https://apify.com/avqelle/date-format-normalizer.md
- **Developed by:** [Avqelle Labs](https://apify.com/avqelle) (community)
- **Categories:** Developer tools, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 dates

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Date Format Normalizer

Normalize messy date strings into clean ISO 8601 or custom date formats.

Date Format Normalizer helps clean inconsistent date values from spreadsheets, CRMs, scraped data, API exports, forms, and automation workflows. It accepts common date formats, relative dates, multilingual date words, and timezone-aware timestamps, then returns consistent structured output.

### What you get

For each input date, the Actor returns:

- The original input value
- A normalized date using your selected output format
- A UTC ISO 8601 datetime with a `Z` suffix
- A success or error status
- A clear error code when parsing fails

Example result:

```json
{
  "input": "Jan 5th 2023",
  "normalized": "2023-01-05",
  "iso8601": "2023-01-05T00:00:00Z",
  "status": "ok",
  "error": null
}
````

### Common use cases

- Clean date columns before importing data into a CRM
- Normalize scraped dates from websites
- Standardize dates from CSV, Excel, Airtable, or Google Sheets exports
- Convert mixed date formats before sending data to an API
- Prepare date fields for databases, analytics, dashboards, or automation tools
- Detect invalid or empty date values in messy datasets

### Features

- Converts common date formats into clean output
- Supports custom output formats using Python `strftime`
- Returns ISO 8601 datetime output in UTC with a `Z` suffix
- Removes microseconds from ISO 8601 output for cleaner results
- Handles relative dates such as `2 days ago`
- Supports multilingual date terms such as `gestern`
- Supports timezone conversion
- Supports ambiguous numeric date handling with date order options
- Returns clear error results for invalid or empty inputs
- Charges only successfully normalized dates

### Input

#### `dates`

Array of date strings to normalize.

Example:

```json
[
  "Jan 5th 2023",
  "05/01/2023",
  "2 days ago",
  "gestern",
  "2023-12-25T10:30:00"
]
```

#### `output_format`

Python `strftime` format used for the `normalized` field.

Default:

```text
%Y-%m-%d
```

Examples:

| Format | Example output |
|---|---|
| `%Y-%m-%d` | `2023-01-05` |
| `%d/%m/%Y` | `05/01/2023` |
| `%B %d %Y` | `January 05 2023` |
| `%Y-%m-%dT%H:%M:%S` | `2023-01-05T00:00:00` |

#### `locale`

Language code used for parsing locale-specific dates.

Examples:

```text
en
de
fr
es
ar
zh
```

Use an empty value for auto-detection. This is useful when your input contains mixed-language dates.

Example:

```json
"locale": ""
```

#### `timezone`

Timezone used to interpret dates without timezone information.

Default:

```text
UTC
```

Examples:

```text
UTC
US/Eastern
Europe/Berlin
Asia/Karachi
```

The `iso8601` output is returned in UTC with a `Z` suffix.

#### `date_order`

Controls ambiguous numeric dates such as `05/01/2023`.

| Value | Meaning |
|---|---|
| empty | Auto, use locale-based date order |
| `MDY` | Month/day/year |
| `DMY` | Day/month/year |
| `YMD` | Year/month/day |

Example:

```json
"date_order": "DMY"
```

With `DMY`, `05/01/2023` is treated as 5 January 2023.

With `MDY`, `05/01/2023` is treated as May 1, 2023.

#### `prefer_dates_from`

Controls how ambiguous relative dates are interpreted.

| Value | Meaning |
|---|---|
| `past` | Prefer past dates |
| `future` | Prefer future dates |
| `current_period` | Prefer the current period |

#### `prefer_day_of_month`

Controls what day should be used when the input has a month and year but no day.

| Value | Meaning |
|---|---|
| `first` | Use the first day of the month |
| `last` | Use the last day of the month |
| `current` | Use the current day number |

### Example input

```json
{
  "dates": [
    "Jan 5th 2023",
    "05/01/2023",
    "2 days ago",
    "gestern",
    "2023-12-25T10:30:00",
    "invalid date",
    ""
  ],
  "output_format": "%Y-%m-%d",
  "locale": "",
  "timezone": "UTC",
  "date_order": "",
  "prefer_dates_from": "current_period",
  "prefer_day_of_month": "current"
}
```

### Example output

```json
[
  {
    "input": "Jan 5th 2023",
    "normalized": "2023-01-05",
    "iso8601": "2023-01-05T00:00:00Z",
    "status": "ok",
    "error": null
  },
  {
    "input": "05/01/2023",
    "normalized": "2023-05-01",
    "iso8601": "2023-05-01T00:00:00Z",
    "status": "ok",
    "error": null
  },
  {
    "input": "2 days ago",
    "normalized": "2026-05-15",
    "iso8601": "2026-05-15T21:35:26Z",
    "status": "ok",
    "error": null
  },
  {
    "input": "gestern",
    "normalized": "2026-05-16",
    "iso8601": "2026-05-16T21:35:26Z",
    "status": "ok",
    "error": null
  },
  {
    "input": "2023-12-25T10:30:00",
    "normalized": "2023-12-25",
    "iso8601": "2023-12-25T10:30:00Z",
    "status": "ok",
    "error": null
  },
  {
    "input": "invalid date",
    "normalized": null,
    "iso8601": null,
    "status": "error",
    "error": "COULD_NOT_PARSE_DATE"
  },
  {
    "input": "",
    "normalized": null,
    "iso8601": null,
    "status": "error",
    "error": "EMPTY_INPUT"
  }
]
```

### Output fields

| Field | Description |
|---|---|
| `input` | Original input value |
| `normalized` | Date formatted using your selected `output_format` |
| `iso8601` | UTC ISO 8601 datetime with `Z` suffix |
| `status` | `ok` for successful parsing, `error` for failed parsing |
| `error` | Error code when parsing fails, otherwise `null` |

### Error codes

| Error | Meaning |
|---|---|
| `EMPTY_INPUT` | The input value was empty |
| `COULD_NOT_PARSE_DATE` | The Actor could not understand the date |
| Other error text | A parser or formatting error occurred |

### Pricing

This Actor is charged only for successfully normalized dates.

Invalid, empty, or unparseable dates are returned with error information and are not charged.

```text
$0.50 per 1,000 successfully normalized dates
```

Equivalent per-result price:

```text
$0.0005 per successfully normalized date
```

The small Actor start fee may also apply.

### Important behavior

#### Relative dates depend on run time

Inputs such as `2 days ago` are calculated based on the time when the Actor runs.

For example, if the Actor runs on May 17, then `2 days ago` resolves to May 15.

#### Relative dates can include the run time

For relative inputs, the `iso8601` value can include the hour, minute, and second from the Actor run time.

Example:

```json
{
  "input": "2 days ago",
  "normalized": "2026-05-15",
  "iso8601": "2026-05-15T21:35:26Z",
  "status": "ok",
  "error": null
}
```

#### Ambiguous dates need date order

The input `05/01/2023` can mean different things in different countries.

Use `date_order` to control this:

```json
"date_order": "MDY"
```

means May 1, 2023.

```json
"date_order": "DMY"
```

means January 5, 2023.

#### Natural language phrase support

This Actor is designed for common dates, relative dates, multilingual date words, and timezone-aware timestamps. Some natural language phrases, such as `next friday`, `last monday`, or `next week`, may not parse consistently. If a value cannot be parsed, the Actor returns an error result instead of failing the whole run.

### Recommended settings

For mixed-language input:

```json
{
  "locale": ""
}
```

For US-style numeric dates:

```json
{
  "date_order": "MDY"
}
```

For European-style numeric dates:

```json
{
  "date_order": "DMY"
}
```

For clean ISO date output:

```json
{
  "output_format": "%Y-%m-%d"
}
```

### Full example

```json
{
  "dates": [
    "Jan 5th 2023",
    "05/01/2023",
    "2 days ago",
    "gestern",
    "2023-12-25T10:30:00"
  ],
  "output_format": "%Y-%m-%d",
  "locale": "",
  "timezone": "UTC",
  "date_order": "",
  "prefer_dates_from": "current_period",
  "prefer_day_of_month": "current"
}
```

### Notes for integrations

The Actor writes one result object per processed input date to the default dataset.

Use the dataset output when connecting this Actor to:

- Apify API
- Zapier
- Make
- Webhooks
- Google Sheets
- Airtable
- CRM imports
- Custom data pipelines

### Support

If a date does not parse as expected, check:

1. Whether the date is ambiguous, such as `05/01/2023`
2. Whether `date_order` is set correctly
3. Whether `locale` should be empty for auto-detection
4. Whether the input contains unsupported natural language phrases
5. Whether the selected `output_format` is a valid Python `strftime` format

# Actor input Schema

## `dates` (type: `array`):

Array of date strings to normalize. Accepts common date formats, ISO dates, US/EU-style dates, relative dates such as '2 days ago', and multilingual dates such as 'gestern'.

## `output_format` (type: `string`):

Python strftime format for normalized output. Default: %Y-%m-%d. Examples: %d/%m/%Y, %B %d %Y, %Y-%m-%dT%H:%M:%S

## `locale` (type: `string`):

Language code for parsing locale-specific dates. Examples: en, de, fr, es, ar, zh. Use an empty value for auto-detection, which is better for mixed-language inputs.

## `timezone` (type: `string`):

Timezone for interpreting ambiguous dates. Examples: UTC, US/Eastern, Europe/Berlin. Output is converted to UTC internally.

## `date_order` (type: `string`):

Controls ambiguous numeric dates such as 05/01/2023. MDY means month/day/year, DMY means day/month/year, and YMD means year/month/day. Leave empty to use locale-based date order.

## `prefer_dates_from` (type: `string`):

For ambiguous relative dates, choose whether to prefer past dates, future dates, or the current period.

## `prefer_day_of_month` (type: `string`):

When the day is missing, choose first day, last day, or today's current day number.

## Actor input object example

```json
{
  "dates": [
    "Jan 5th 2023",
    "05/01/2023",
    "2 days ago",
    "gestern",
    "2023-12-25T10:30:00"
  ],
  "output_format": "%Y-%m-%d",
  "locale": "",
  "timezone": "UTC",
  "date_order": "",
  "prefer_dates_from": "current_period",
  "prefer_day_of_month": "current"
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("avqelle/date-format-normalizer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("avqelle/date-format-normalizer").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 '{}' |
apify call avqelle/date-format-normalizer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Date Format Normalizer",
        "description": "Normalize messy date strings into clean ISO 8601 or custom date formats. Handles common date formats, relative dates, multilingual inputs, timezone conversion, and returns clear error results for unparseable dates.",
        "version": "0.0",
        "x-build-id": "2aenFf0cTX0k5SIcN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/avqelle~date-format-normalizer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-avqelle-date-format-normalizer",
                "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/avqelle~date-format-normalizer/runs": {
            "post": {
                "operationId": "runs-sync-avqelle-date-format-normalizer",
                "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/avqelle~date-format-normalizer/run-sync": {
            "post": {
                "operationId": "run-sync-avqelle-date-format-normalizer",
                "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": [
                    "dates"
                ],
                "properties": {
                    "dates": {
                        "title": "Date Strings",
                        "type": "array",
                        "description": "Array of date strings to normalize. Accepts common date formats, ISO dates, US/EU-style dates, relative dates such as '2 days ago', and multilingual dates such as 'gestern'.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Jan 5th 2023",
                            "05/01/2023",
                            "2 days ago",
                            "gestern",
                            "2023-12-25T10:30:00"
                        ]
                    },
                    "output_format": {
                        "title": "Output Format",
                        "type": "string",
                        "description": "Python strftime format for normalized output. Default: %Y-%m-%d. Examples: %d/%m/%Y, %B %d %Y, %Y-%m-%dT%H:%M:%S",
                        "default": "%Y-%m-%d"
                    },
                    "locale": {
                        "title": "Input Locale",
                        "type": "string",
                        "description": "Language code for parsing locale-specific dates. Examples: en, de, fr, es, ar, zh. Use an empty value for auto-detection, which is better for mixed-language inputs.",
                        "default": ""
                    },
                    "timezone": {
                        "title": "Timezone",
                        "type": "string",
                        "description": "Timezone for interpreting ambiguous dates. Examples: UTC, US/Eastern, Europe/Berlin. Output is converted to UTC internally.",
                        "default": "UTC"
                    },
                    "date_order": {
                        "title": "Date Order",
                        "enum": [
                            "",
                            "MDY",
                            "DMY",
                            "YMD"
                        ],
                        "type": "string",
                        "description": "Controls ambiguous numeric dates such as 05/01/2023. MDY means month/day/year, DMY means day/month/year, and YMD means year/month/day. Leave empty to use locale-based date order.",
                        "default": ""
                    },
                    "prefer_dates_from": {
                        "title": "Prefer Dates From",
                        "enum": [
                            "past",
                            "future",
                            "current_period"
                        ],
                        "type": "string",
                        "description": "For ambiguous relative dates, choose whether to prefer past dates, future dates, or the current period.",
                        "default": "current_period"
                    },
                    "prefer_day_of_month": {
                        "title": "Prefer Day of Month",
                        "enum": [
                            "first",
                            "last",
                            "current"
                        ],
                        "type": "string",
                        "description": "When the day is missing, choose first day, last day, or today's current day number.",
                        "default": "current"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```