# NJ Property Tax Assessment Lookup (MOD-IV) (`ben_malaga/nj-property-tax-actor`) Actor

Query New Jersey property tax assessment data from the official MOD-IV database. Search by address, block/lot, municipality, zip code, or PAMS PIN. Returns assessed values, sale data, and computed analytics including tax appeal scoring, implied market value, and comparable properties.

- **URL**: https://apify.com/ben\_malaga/nj-property-tax-actor.md
- **Developed by:** [Ben Malaga](https://apify.com/ben_malaga) (community)
- **Categories:** Real estate, Agents
- **Stats:** 1 total users, 0 monthly users, 98.1% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 NJ Property Tax Assessment Lookup do?

**NJ Property Tax Assessment Lookup** queries New Jersey's official **MOD-IV property tax assessment database** — the same data used by county tax boards, appraisers, and real estate professionals. It pulls assessment records from the NJ Geographic Information Network's public ArcGIS REST API and enriches every record with **computed analytics** including tax appeal opportunity scoring, implied market value, comparable properties, and municipality percentile rankings.

Search by street address, block/lot, zip code, PAMS PIN, or export an entire municipality's records in bulk. Results are returned as structured JSON and available via the Apify API, scheduled runs, webhooks, and 100+ integrations.

### Why use NJ Property Tax Assessment Lookup?

- **Tax appeal analysis** — Automatically score every property's appeal opportunity by comparing assessments against county equalization ratios. Identify over-assessed properties at scale.
- **Market value estimation** — Get implied market values derived from official county equalization ratios without needing to pull comps manually.
- **Comparable property search** — For any single property, find the 5 most similar parcels in the same municipality by property class, age, and assessed value.
- **Bulk data export** — Export all parcels for an entire municipality or zip code. Perfect for market research, portfolio analysis, or building property databases.
- **Scheduled monitoring** — Run on a schedule via Apify to track assessment changes over time.

### How to use NJ Property Tax Assessment Lookup

1. Click **Try for free** to open the Actor in the Apify Console.
2. Select a **Search Mode** — choose how you want to find properties.
3. Fill in the required fields for your search mode (address, block/lot, etc.).
4. Optionally enable **Include Comparable Properties** or **Include Municipality Percentile** for single-property deep dives.
5. Click **Start** and wait for results to appear in the Output tab.
6. Download results as JSON, CSV, Excel, or connect via API.

### Input

The Actor accepts the following input parameters. You can also configure these in the Apify Console UI.

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `searchMode` | string | Yes | One of: `address`, `blockLot`, `municipality`, `zipCode`, `pamsPin` |
| `address` | string | For address mode | Street address (e.g., "80 RIVER ST"). Partial matches supported. |
| `municipality` | string | For address/blockLot/municipality modes | Municipality name (e.g., "HOBOKEN", "NEWARK CITY") |
| `block` | string | For blockLot mode | Tax map block number |
| `lot` | string | For blockLot mode | Tax map lot number |
| `qualifier` | string | No | Qualifier code for condos/units (e.g., "C0101") |
| `zipCode` | string | For zipCode mode | 5-digit zip code |
| `pamsPin` | string | For pamsPin mode | Exact PAMS PIN (e.g., "0905_222_6") |
| `maxResults` | integer | No | Max records to return (default: 10,000) |
| `includeComparables` | boolean | No | Find 5 comparable properties (single-property lookups only) |
| `includePercentile` | boolean | No | Compute municipality assessment percentile (single-property lookups only) |

#### Example input

```json
{
    "searchMode": "address",
    "address": "80 RIVER ST",
    "municipality": "HOBOKEN",
    "includeComparables": true,
    "includePercentile": true
}
````

### Output

Each property record includes raw assessment data plus computed analytics. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output (simplified)

```json
{
    "pamsPin": "0905_222_6",
    "block": "222",
    "lot": "6",
    "municipality": "HOBOKEN CITY",
    "county": "HUDSON",
    "propertyLocation": "80 RIVER ST",
    "propertyClass": "4A",
    "propertyClassLabel": "Commercial",
    "landValue": 4230000,
    "improvementValue": 7733000,
    "netValue": 11963000,
    "lastYearTax": 222990.32,
    "salePrice": 1,
    "yearConstructed": null,
    "calculatedAcres": 0.188,
    "effectiveTaxRate": 1.8639,
    "impliedMarketValue": 17027758,
    "countyEqualizationRatio": 70.25,
    "taxAppealScore": null,
    "assessmentToSaleRatio": null,
    "landToTotalRatio": 0.3536,
    "buildingAge": null,
    "municipalityPercentile": 99,
    "municipalityMedianAssessment": 522500,
    "municipalityTotalParcels": 18909,
    "comparables": [
        {
            "pamsPin": "0905_116_1",
            "propertyLocation": "100 WASHINGTON ST",
            "netValue": 12500000,
            "lastYearTax": 233125.0,
            "valueDifference": 537000
        }
    ]
}
```

### Data fields

| Field | Description |
|-------|-------------|
| `pamsPin` | Unique parcel identifier |
| `block` / `lot` / `qualifier` | Tax map identifiers |
| `municipality` / `county` | Location |
| `propertyLocation` | Street address |
| `propertyClassLabel` | Human-readable property type (Residential, Commercial, etc.) |
| `landValue` / `improvementValue` / `netValue` | Assessed values |
| `lastYearTax` | Actual tax paid last year |
| `salePrice` / `deedDate` | Last recorded sale |
| `yearConstructed` | Year the building was built |
| `effectiveTaxRate` | Tax as % of assessed value |
| `impliedMarketValue` | Estimated market value from county equalization ratio |
| `countyEqualizationRatio` | County's average assessment-to-market ratio |
| `assessmentOverMarketPct` | How much this property is over/under-assessed vs county average |
| `taxAppealScore` | HIGH / MEDIUM / LOW appeal opportunity |
| `landToTotalRatio` | Land value as fraction of total |
| `assessmentToSaleRatio` | Assessment divided by sale price |
| `buildingAge` | Years since construction |
| `comparables` | Up to 5 similar properties (when enabled) |
| `municipalityPercentile` | Assessment ranking within municipality (when enabled) |

### How much does it cost to query NJ property data?

The Actor uses **pay-per-event pricing**. You are charged per property record returned. A single property lookup with comparables and percentile costs very little. Bulk municipality exports (thousands of records) cost more but are still economical.

The NJ MODIV API is free and public — no proxy costs are involved. The Actor makes direct HTTP requests without any browser overhead, keeping compute usage minimal.

### Tips

- **Use address mode** for quick single-property lookups. Partial addresses work (e.g., "80 RIVER" will match "80 RIVER ST").
- **Municipality names** include type suffixes in the database (e.g., "HOBOKEN CITY", "PRINCETON TWP"). Use partial matches — searching "HOBOKEN" will find "HOBOKEN CITY".
- **Block/lot mode** is the most precise — use it when you know the exact tax map identifiers.
- **PAMS PIN** is a unique identifier in format like "0905\_222\_6" (municipality\_block\_lot).
- **Tax appeal scores** require a meaningful sale price (>$100) to compute. Properties with only nominal $1 transfers won't get scored.
- **Comparables** search for parcels with the same property class, similar assessed value (+/- 40%), and similar build year (+/- 15 years) in the same municipality.
- **Set maxResults** to limit bulk exports if you don't need every record.

### FAQ, disclaimers, and support

**Is this data public?** Yes. All data comes from the NJ Geographic Information Network's public ArcGIS REST API. Owner names are redacted under Daniel's Law.

**How current is the data?** The MODIV database is updated by the NJ Division of Taxation. Assessment values typically reflect the most recent tax year.

**Are the equalization ratios accurate?** The Actor includes county equalization ratios from the NJ Division of Taxation's 2024 publications. These are updated annually — check the source code for the latest values.

**Is this legal advice?** No. Tax appeal scores are informational estimates only. Consult a tax professional or attorney before filing a tax appeal.

**Known limitations:**

- Maximum 2,000 records per API page (handled automatically with pagination)
- Owner names are redacted (Daniel's Law)
- Equalization ratios are hardcoded and need annual updates

For issues or feature requests, visit the **Issues** tab on the Actor page. For custom solutions or integrations, reach out through the Apify platform.

### Getting started locally

```bash
## Install dependencies
npm install

## Run locally with the default INPUT.json
apify run

## Deploy to Apify platform
apify login
apify push
```

# Actor input Schema

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

How to search for properties. Choose the search method that matches the data you have.

## `address` (type: `string`):

Street address to search for (e.g., '80 RIVER ST'). Partial matches are supported.

## `municipality` (type: `string`):

Municipality name (e.g., 'HOBOKEN', 'NEWARK CITY', 'PRINCETON'). Partial matches are supported.

## `block` (type: `string`):

Tax map block number for block/lot search.

## `lot` (type: `string`):

Tax map lot number for block/lot search.

## `qualifier` (type: `string`):

Optional qualifier code for condos/units (e.g., 'C0101').

## `zipCode` (type: `string`):

5-digit zip code to search (e.g., '07030').

## `pamsPin` (type: `string`):

Exact PAMS PIN identifier (e.g., '0905\_222\_6').

## `maxResults` (type: `integer`):

Maximum number of property records to return. Set to 0 for unlimited. Default is 10,000.

## `includeComparables` (type: `boolean`):

For single-property lookups: find up to 5 comparable properties in the same municipality with similar property class, age, and assessed value. Adds extra API calls.

## `includePercentile` (type: `boolean`):

For single-property lookups: compute what percentile this property's assessment falls in within the municipality. Adds extra API calls.

## Actor input object example

```json
{
  "searchMode": "address",
  "address": "80 RIVER ST",
  "municipality": "HOBOKEN",
  "maxResults": 10000,
  "includeComparables": false,
  "includePercentile": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "address": "80 RIVER ST",
    "municipality": "HOBOKEN"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ben_malaga/nj-property-tax-actor").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 = {
    "address": "80 RIVER ST",
    "municipality": "HOBOKEN",
}

# Run the Actor and wait for it to finish
run = client.actor("ben_malaga/nj-property-tax-actor").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 '{
  "address": "80 RIVER ST",
  "municipality": "HOBOKEN"
}' |
apify call ben_malaga/nj-property-tax-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ben_malaga/nj-property-tax-actor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NJ Property Tax Assessment Lookup (MOD-IV)",
        "description": "Query New Jersey property tax assessment data from the official MOD-IV database. Search by address, block/lot, municipality, zip code, or PAMS PIN. Returns assessed values, sale data, and computed analytics including tax appeal scoring, implied market value, and comparable properties.",
        "version": "1.0",
        "x-build-id": "QGlodScttTRGhelfM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ben_malaga~nj-property-tax-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ben_malaga-nj-property-tax-actor",
                "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/ben_malaga~nj-property-tax-actor/runs": {
            "post": {
                "operationId": "runs-sync-ben_malaga-nj-property-tax-actor",
                "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/ben_malaga~nj-property-tax-actor/run-sync": {
            "post": {
                "operationId": "run-sync-ben_malaga-nj-property-tax-actor",
                "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": [
                    "searchMode"
                ],
                "properties": {
                    "searchMode": {
                        "title": "Search Mode",
                        "enum": [
                            "address",
                            "blockLot",
                            "municipality",
                            "zipCode",
                            "pamsPin"
                        ],
                        "type": "string",
                        "description": "How to search for properties. Choose the search method that matches the data you have.",
                        "default": "address"
                    },
                    "address": {
                        "title": "Street Address",
                        "type": "string",
                        "description": "Street address to search for (e.g., '80 RIVER ST'). Partial matches are supported."
                    },
                    "municipality": {
                        "title": "Municipality",
                        "type": "string",
                        "description": "Municipality name (e.g., 'HOBOKEN', 'NEWARK CITY', 'PRINCETON'). Partial matches are supported."
                    },
                    "block": {
                        "title": "Block",
                        "type": "string",
                        "description": "Tax map block number for block/lot search."
                    },
                    "lot": {
                        "title": "Lot",
                        "type": "string",
                        "description": "Tax map lot number for block/lot search."
                    },
                    "qualifier": {
                        "title": "Qualifier (optional)",
                        "type": "string",
                        "description": "Optional qualifier code for condos/units (e.g., 'C0101')."
                    },
                    "zipCode": {
                        "title": "Zip Code",
                        "type": "string",
                        "description": "5-digit zip code to search (e.g., '07030')."
                    },
                    "pamsPin": {
                        "title": "PAMS PIN",
                        "type": "string",
                        "description": "Exact PAMS PIN identifier (e.g., '0905_222_6')."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of property records to return. Set to 0 for unlimited. Default is 10,000.",
                        "default": 10000
                    },
                    "includeComparables": {
                        "title": "Include Comparable Properties",
                        "type": "boolean",
                        "description": "For single-property lookups: find up to 5 comparable properties in the same municipality with similar property class, age, and assessed value. Adds extra API calls.",
                        "default": false
                    },
                    "includePercentile": {
                        "title": "Include Municipality Percentile",
                        "type": "boolean",
                        "description": "For single-property lookups: compute what percentile this property's assessment falls in within the municipality. Adds extra API calls.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
