# IPinfo / MaxMind GeoLite2 Replacement — DB-IP Powered IP Lookup (`nexgendata/ip-geolocation-replacement`) Actor

IPinfo gutted its free tier. MaxMind wants a license key. Here's the drop-in replacement: country, region, city, lat/lng, ASN, timezone, VPN/proxy heuristics — unified JSON schema, $0.0005/IP.

- **URL**: https://apify.com/nexgendata/ip-geolocation-replacement.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Developer tools, Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / 1,000 ip geolocation lookups

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

## IPinfo / MaxMind GeoLite2 Replacement — DB-IP Powered IP Geolocation

**IPinfo gutted its free tier. MaxMind wants a license key. Here's the drop-in replacement at $0.0005 per IP lookup.**

If you landed here, you already know the story. In 2025 IPinfo cut its once-generous free tier down to a shadow of itself — 1,000 lookups/day is fine for a hobby project, useless in production. MaxMind's GeoLite2 is still "free," but only after you create an account, accept an EULA, generate a license key, and set up auto-updating infrastructure — all of which broke for thousands of users when MaxMind tightened registration requirements in December 2024. Every week someone asks on Stack Overflow why their `GeoIP2.mmdb` download is now returning 401s.

This actor is the straightforward escape hatch. No registration. No license keys. No auto-updater cron jobs. Feed it a list of IPv4 or IPv6 addresses, get back a unified JSON record for each: country, region, city, lat/lng, ASN, ISP, timezone, and optional VPN/proxy heuristics. One flat rate, no tiering games.

### What it does

For each IP you pass in, the actor returns a record shaped like this:

```json
{
  "ip": "8.8.8.8",
  "country_code": "US",
  "country_name": "United States",
  "region": "California",
  "city": "Mountain View",
  "latitude": 37.4056,
  "longitude": -122.0775,
  "timezone": "America/Los_Angeles",
  "asn": 15169,
  "asn_org": "Google LLC",
  "is_proxy": false,
  "is_vpn": false,
  "data_source": "dbip+ipwho.is",
  "lookup_time_ms": 4
}
````

Every field is stable. If something can't be resolved, you get `null` and a `data_source: "error"` marker instead of a cryptic stack trace — which means downstream pipelines don't crash when a single IP is bogus.

### How it works (and why it's fast)

The primary data source is the **DB-IP Lite** dataset, which ships under a CC-BY-4.0 license. DB-IP publishes a fresh CSV snapshot every month covering both city-level geolocation and ASN/ISP records. The actor downloads the latest gzipped CSV on first run, caches it to `/tmp`, parses both files into sorted in-memory range trees, and resolves each IP via `bisect` — O(log n) per lookup, measured in microseconds once the dataset is in memory.

What that means in practice:

- **First run:** ~20-40 seconds to download and parse the datasets (two CSVs totalling ~50 MB gzipped).
- **Subsequent lookups:** sub-millisecond per IP once loaded. A run of 1,000 IPs typically finishes the IP-resolution phase in under a second.
- **No per-lookup outbound calls** for the core geolocation data. You're not being throttled by somebody else's rate limiter.

For VPN / proxy detection — which DB-IP Lite doesn't include — the actor optionally hits the free [ipwho.is](https://ipwho.is) API. Set `include_vpn_check: true` to turn it on. This path is rate-limited by ipwho.is (roughly 10,000 requests/month per requesting IP prefix, per their public docs), so leave it off unless you actually need the flags.

#### The hybrid fallback

Real-world robustness note: if the DB-IP CDN is slow or throws a 5xx during download, the actor doesn't just fail. It falls back to calling ipwho.is directly for every input IP. You lose the sub-millisecond local-lookup speed, but the JSON output shape is identical and your run still succeeds. The `data_source` key (`"dbip"` / `"ipwho.is"` / `"dbip+ipwho.is"` / `"error"`) tells you exactly which backend served each record, so you can audit upstream reliability on your own datasets.

### Input

```json
{
  "ips": ["8.8.8.8", "1.1.1.1", "208.67.222.222", "2606:4700:4700::1111"],
  "include_asn": true,
  "include_vpn_check": false,
  "batch_size": 50
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `ips` | `string[]` | — | 1 to 1,000 IPv4 or IPv6 addresses. |
| `include_asn` | `bool` | `true` | Attach `asn` + `asn_org` from the DB-IP ASN Lite dataset. |
| `include_vpn_check` | `bool` | `false` | Call ipwho.is to populate `is_proxy` / `is_vpn`. |
| `batch_size` | `int` | `50` | Max concurrent per-IP tasks (1-100). |

### Output schema

One dataset record per input IP. The full field set is documented in `.actor/dataset_schema.json`. Highlights:

- `country_code`, `country_name`, `region`, `city` — human-readable location.
- `latitude`, `longitude` — decimal coordinates, typically accurate to a few kilometers at city level.
- `timezone` — IANA identifier (e.g. `"America/New_York"`).
- `asn`, `asn_org` — Autonomous System Number + organization.
- `is_proxy`, `is_vpn` — null unless `include_vpn_check: true`.
- `data_source` — `"dbip"`, `"ipwho.is"`, `"dbip+ipwho.is"`, or `"error"`.
- `lookup_time_ms` — per-IP wall-clock resolution time.

### Pricing

**$0.0005 per IP lookup** (event: `ip-lookup`). That's:

- 1/60th of what IPinfo charges ($0.03/lookup on their paid plans, ballpark).
- Roughly half of MaxMind's per-lookup cost on their licensed GeoIP2 products, without the flat annual fee.
- Cheap enough that a 10,000-IP enrichment job costs $5.

You're paying for the orchestration, the CDN hit for the monthly DB-IP snapshot, the hybrid fallback logic, and the stable unified schema. The underlying data is CC-BY-4.0 — attribution to DB-IP is baked into this README and required for any redistribution of the raw dataset, but not for your use of the JSON output.

### When *not* to use this

Be honest about the tradeoffs:

- **City-level accuracy.** DB-IP Lite, like MaxMind GeoLite2, gives you city — not street. If you need rooftop accuracy, you need a commercial dataset (and you're going to pay 100x more for it).
- **Mobile carrier IPs.** Cellular NAT pools bounce around; country is reliable, city often isn't. This is true of every IP geolocation provider.
- **Real-time fraud scoring.** `is_proxy` / `is_vpn` here are a basic heuristic from ipwho.is. For high-stakes fraud workflows you still want a dedicated vendor like IPQualityScore or FingerprintJS.
- **Sub-second sync lookups embedded in a hot request path.** This is a batch-oriented Apify actor, not a sidecar daemon. If you need per-request latency under 10ms, load the DB-IP CSV directly into your own process.

For "we need to enrich a million log lines a day with country + city + ASN, without getting rug-pulled by another provider" — this is exactly the tool.

### Example run

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("nexgendata/ip-geolocation-replacement").call(
    run_input={
        "ips": ["8.8.8.8", "1.1.1.1", "208.67.222.222"],
        "include_asn": True,
        "include_vpn_check": False,
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["ip"], "->", item["city"], item["country_code"], "|", item["asn_org"])
```

Expected output:

```
8.8.8.8 -> Mountain View US | Google LLC
1.1.1.1 -> Sydney AU | Cloudflare, Inc.
208.67.222.222 -> San Francisco US | Cisco OpenDNS LLC
```

### Caveats & honest notes

- **DB-IP CDN flakiness.** On a cold Apify container, downloading ~50 MB from the DB-IP mirror usually takes 15-30 seconds, but we've seen occasional 5xx spikes. The actor transparently falls back to ipwho.is when that happens — you'll see `data_source: "ipwho.is"` on every record and a warning in the log. Your results are still valid; they're just slower and subject to ipwho.is's per-prefix rate limits.
- **Country-name coverage.** The built-in `country_code -> country_name` map covers ~70 common countries. For unlisted codes, `country_name` falls back to the uppercase two-letter code — `is_proxy` / `asn` / lat-lng are unaffected.
- **Attribution.** Data is sourced from DB-IP Lite (https://db-ip.com, CC-BY-4.0) and ipwho.is (free tier). If you republish the raw CSV, maintain attribution. If you ship downstream features built on the JSON output, you don't have to.
- **Monthly data freshness.** DB-IP publishes new Lite snapshots on the first of each month. The actor's `/tmp` cache is per-container, so a cold start pulls the latest automatically.

### Why this exists

NexGenData builds drop-in replacements for "freemium → gated" data APIs. IPinfo's 2025 tier cut and MaxMind's license-key enforcement created a clear gap. DB-IP has been the quietly-excellent third choice for years, but using its CSV raw requires rolling your own range-tree parser, caching layer, and fallback logic. We did that. You get a stable Apify actor with one-line integration and a flat $0.0005/IP price.

If you're escaping IPinfo or wrestling with MaxMind's license-key plumbing, this is the fastest path forward.

### Related tools

- [📜 WHOIS Replacement — Domain Registration & Expiry API](https://apify.com/nexgendata/whois-replacement?fpr=2ayu9b)
- [📊 Tranco Rank Lookup — Alexa Rank Alternative](https://apify.com/nexgendata/tranco-rank-lookup?fpr=2ayu9b)
- [🧱 Company Tech Stack Detector — BuiltWith Alternative](https://apify.com/nexgendata/company-tech-stack-detector?fpr=2ayu9b)
- [🛰️ DNS Propagation Checker — Global Resolver Sweep](https://apify.com/nexgendata/dns-propagation-checker?fpr=2ayu9b)

# Actor input Schema

## `ips` (type: `array`):

List of IPv4 or IPv6 addresses to geolocate (1-1000). Example: \["8.8.8.8", "1.1.1.1", "2606:4700:4700::1111"]. Each entry returns one unified record and incurs one PPE charge.

## `include_asn` (type: `boolean`):

Attach the `asn` and `asn_org` fields (AS number + organization/ISP name) to each record. Uses the DB-IP ASN Lite dataset when available, with an ipwho.is fallback. Defaults to true.

## `include_vpn_check` (type: `boolean`):

Populate `is_proxy` and `is_vpn` by cross-referencing the free ipwho.is API for each IP. Adds ~200ms per IP and is rate-limited by ipwho.is (roughly 10k req/mo per IP prefix). Defaults to false.

## `batch_size` (type: `integer`):

Number of IPs resolved concurrently (1-100). Larger = faster but more likely to trip upstream rate limits. Defaults to 50.

## `user_agent` (type: `string`):

Optional User-Agent string for upstream calls (DB-IP CDN + ipwho.is). Leave blank to use the default.

## Actor input object example

```json
{
  "ips": [
    "8.8.8.8",
    "1.1.1.1",
    "208.67.222.222"
  ],
  "include_asn": true,
  "include_vpn_check": false,
  "batch_size": 50,
  "user_agent": ""
}
```

# 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 = {
    "ips": [
        "8.8.8.8",
        "1.1.1.1",
        "208.67.222.222"
    ],
    "include_asn": true,
    "include_vpn_check": false,
    "batch_size": 50,
    "user_agent": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/ip-geolocation-replacement").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 = {
    "ips": [
        "8.8.8.8",
        "1.1.1.1",
        "208.67.222.222",
    ],
    "include_asn": True,
    "include_vpn_check": False,
    "batch_size": 50,
    "user_agent": "",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/ip-geolocation-replacement").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 '{
  "ips": [
    "8.8.8.8",
    "1.1.1.1",
    "208.67.222.222"
  ],
  "include_asn": true,
  "include_vpn_check": false,
  "batch_size": 50,
  "user_agent": ""
}' |
apify call nexgendata/ip-geolocation-replacement --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "IPinfo / MaxMind GeoLite2 Replacement — DB-IP Powered IP Lookup",
        "description": "IPinfo gutted its free tier. MaxMind wants a license key. Here's the drop-in replacement: country, region, city, lat/lng, ASN, timezone, VPN/proxy heuristics — unified JSON schema, $0.0005/IP.",
        "version": "0.0",
        "x-build-id": "GLZ06TptEaYBVTQwt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~ip-geolocation-replacement/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-ip-geolocation-replacement",
                "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/nexgendata~ip-geolocation-replacement/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-ip-geolocation-replacement",
                "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/nexgendata~ip-geolocation-replacement/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-ip-geolocation-replacement",
                "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": [
                    "ips"
                ],
                "properties": {
                    "ips": {
                        "title": "IP Addresses",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "List of IPv4 or IPv6 addresses to geolocate (1-1000). Example: [\"8.8.8.8\", \"1.1.1.1\", \"2606:4700:4700::1111\"]. Each entry returns one unified record and incurs one PPE charge.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "include_asn": {
                        "title": "Include ASN / ISP Data",
                        "type": "boolean",
                        "description": "Attach the `asn` and `asn_org` fields (AS number + organization/ISP name) to each record. Uses the DB-IP ASN Lite dataset when available, with an ipwho.is fallback. Defaults to true.",
                        "default": true
                    },
                    "include_vpn_check": {
                        "title": "Include VPN / Proxy Heuristics",
                        "type": "boolean",
                        "description": "Populate `is_proxy` and `is_vpn` by cross-referencing the free ipwho.is API for each IP. Adds ~200ms per IP and is rate-limited by ipwho.is (roughly 10k req/mo per IP prefix). Defaults to false.",
                        "default": false
                    },
                    "batch_size": {
                        "title": "Batch Size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of IPs resolved concurrently (1-100). Larger = faster but more likely to trip upstream rate limits. Defaults to 50.",
                        "default": 50
                    },
                    "user_agent": {
                        "title": "User-Agent Override",
                        "type": "string",
                        "description": "Optional User-Agent string for upstream calls (DB-IP CDN + ipwho.is). Leave blank to use the default.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```