# CAP Alert Extractor (OASIS CAP 1.2 emergency alerts) (`datamule/cap-alert-extractor`) Actor

Point at ANY CAP alerting authority (US NWS, UN GDACS, Canada NAAD, PH PAGASA, NZ MetService + more in the WMO Register) and extract OASIS CAP 1.2 alerts as flat rows. Auto-decodes GeoJSON, inline CAP-XML feeds and Atom/RSS-linked CAP docs. One row per alert x info-language x area, with geometry.

- **URL**: https://apify.com/datamule/cap-alert-extractor.md
- **Developed by:** [Datamule](https://apify.com/datamule) (community)
- **Categories:** Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 alert records

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## CAP Alert Extractor

**Point at ANY CAP alerting authority and get structured emergency-alert rows.**

This Actor is a **generic runner** over the [OASIS Common Alerting Protocol (CAP) 1.2](https://docs.oasis-open.org/emergency/cap/v1.2/CAP-v1.2-os.html)
— the international standard that national meteorological and emergency-management
agencies use to publish public warnings (severe weather, floods, earthquakes,
tsunamis, air-quality, civil emergencies). The
[WMO Register of Alerting Authorities](https://alertingauthority.wmo.int/) lists
~130 authorities that publish CAP. Give this Actor any of their feeds — or a single
CAP document — and get flat, analysis-ready rows. **No per-country scraper needed.**

### Why this is one Actor, not a hundred

Every authority speaks CAP, but they serialize it **three different ways** on the
wire. This Actor auto-detects and decodes all three, so a single input works
everywhere:

| Serialization | Example authority | What it looks like |
|---|---|---|
| **GeoJSON** | US NWS (`api.weather.gov/alerts/active`) | one `features[]` per alert, CAP fields in `properties` |
| **Inline CAP-XML feed** | UN GDACS (`gdacs_cap.xml`) | an RSS feed where each `<item>` embeds a full `<cap:alert>` |
| **Atom/RSS → linked CAP docs** | Canada NAAD, PH PAGASA, NZ MetService | a feed whose entries **link** to standalone CAP XML documents (auto-followed) |

It also handles the details the CAP spec leaves to the publisher:

- the `cap:` namespace prefix is **optional and inconsistent** — elements are
  matched by local-name, so `<cap:alert>`, `<alert>`, and default-namespaced
  documents all parse.
- `<area>` geometry can be a **polygon, a circle, or a geocode** (SAME / FIPS /
  UGC) — all three shapes are captured; alerts with only a geocode are fine.
- `status: Test` / `Exercise` and `msgType: Cancel` / `Update` are real CAP values
  — the `status` filter (default `Actual`) keeps test messages out of your data,
  and `msgType` is surfaced so a *Cancel* is never mistaken for a live warning.
- **multi-language alerts** (Canadian EN+FR, EU 24-language) emit one row per
  language.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrl` | string (required) | — | A CAP feed URL (GeoJSON / CAP-XML / Atom-RSS) or a single CAP XML document URL |
| `mode` | enum `feed` \| `alert` | `feed` | `feed` lists current alerts from a feed; `alert` parses one CAP document |
| `status` | enum | `Actual` | Only emit alerts with this CAP `status` (empty = any). Keeps Test/Exercise out |
| `severity` | enum | (any) | Filter by CAP `severity` (Extreme / Severe / Moderate / Minor / Unknown) |
| `urgency` | enum | (any) | Filter by CAP `urgency` (Immediate / Expected / Future / Past / Unknown) |
| `certainty` | enum | (any) | Filter by CAP `certainty` (Observed / Likely / Possible / Unlikely / Unknown) |
| `maxRecords` | integer | 1000 | Stop after this many rows |
| `userAgent` | string | (built-in) | Override the User-Agent (some authorities request a descriptive UA) |
| `timeoutSecs` | integer | 60 | Per-request timeout |

#### Example inputs

```json
{ "startUrl": "https://api.weather.gov/alerts/active", "mode": "feed", "status": "Actual" }
````

```json
{ "startUrl": "https://www.gdacs.org/xml/gdacs_cap.xml", "mode": "feed", "severity": "Severe" }
```

```json
{ "startUrl": "https://rss.naad-adna.pelmorex.com/", "mode": "feed" }
```

```json
{ "startUrl": "https://alerts.metservice.com/cap/rss", "mode": "feed" }
```

### Output

The natural billable **row is (alert × info-language × area)** — one CAP `<alert>`
with 2 language `<info>` blocks each covering 7 `<area>` blocks yields 14 rows. Every
row is a flat, fully-nullable superset carrying alert-level fields (`identifier`,
`sender`, `sent`, `status`, `msgType`, `scope`, `references`, `incidents`),
info-level fields (`language`, `categories`, `event`, `responseTypes`, `urgency`,
`severity`, `certainty`, `effective`, `onset`, `expires`, `senderName`, `headline`,
`description`, `instruction`, `eventCodes`, `parameters`), and area-level fields
(`areaDesc`, `polygons`, `circles`, `geocodes`, `altitude`, `ceiling`), plus
provenance (`_sourceUrl`, `_capUrl`, `_mode`, `_rowIndex`, and the lossless `_raw`
CAP XML when applicable).

```json
{
  "identifier": "urn:oid:2.49.0.1.840...",
  "sender": "w-nws.webmaster@noaa.gov",
  "sent": "2026-07-09T12:26:00-04:00",
  "status": "Actual",
  "msgType": "Update",
  "language": "en-US",
  "event": "Flood Watch",
  "severity": "Severe",
  "urgency": "Future",
  "certainty": "Possible",
  "effective": "2026-07-09T12:26:00-04:00",
  "expires": "2026-07-10T00:00:00-04:00",
  "senderName": "NWS State College PA",
  "headline": "Flood Watch issued July 9 ...",
  "areaDesc": "Perry; Dauphin; Lebanon; Cumberland; Adams; York; Lancaster",
  "geocodes": [{ "valueName": "SAME", "value": "042099" }, { "valueName": "UGC", "value": "PAZ056" }]
}
```

### Honest behavior

- A reachable feed with **0 in-window alerts is a real result** (exit 0, zero rows)
  — not an error.
- If **every** source is unreachable / unparseable, the Actor **fails fast** rather
  than emitting a fabricated empty success, so you can trust a 0-row run.
- It never invents rows and never reports an error as an honest empty.

### Pricing

Pay-per-event: **$0.0005 per alert record** (one alert × info × area row), with a
volume discount across subscription tiers.

### Notes

- Metadata only — the Actor reads the alert content the authority publishes; it does
  not download any linked binary attachments.
- Discover more authorities and their feed URLs in the
  [WMO Register of Alerting Authorities](https://alertingauthority.wmo.int/).

# Actor input Schema

## `startUrl` (type: `string`):

A CAP alerting-authority source URL. In 'feed' mode: a GeoJSON alerts endpoint (US NWS https://api.weather.gov/alerts/active), a CAP-XML RSS feed of inline alerts (UN GDACS https://www.gdacs.org/xml/gdacs\_cap.xml), or an Atom/RSS feed whose entries link to CAP docs (Canada NAAD https://rss.naad-adna.pelmorex.com/, PH PAGASA https://publicalert.pagasa.dost.gov.ph/feeds/, NZ MetService https://alerts.metservice.com/cap/rss). In 'alert' mode: a single CAP XML document URL. The serialization is auto-detected. Discover more authorities in the WMO Register of Alerting Authorities.

## `mode` (type: `string`):

'feed' (default) lists the current alerts from a feed/index (auto-detecting GeoJSON, an inline-CAP-XML feed, or an Atom/RSS feed that links to CAP docs). 'alert' parses ONE CAP XML document (startUrl points straight at a single <alert>) into its info/area rows.

## `status` (type: `string`):

Only emit alerts with this CAP <status>. Default 'Actual' so Test/Exercise/Draft messages are never surfaced as real warnings. Set to empty to keep every status. Alerts that omit <status> are kept.

## `severity` (type: `string`):

Only emit rows whose CAP <severity> matches (case-insensitive). Leave empty for all severities.

## `urgency` (type: `string`):

Only emit rows whose CAP <urgency> matches (case-insensitive). Leave empty for all.

## `certainty` (type: `string`):

Only emit rows whose CAP <certainty> matches (case-insensitive). Leave empty for all.

## `maxRecords` (type: `integer`):

Stop after emitting this many (alert × info × area) rows.

## `userAgent` (type: `string`):

Override the default User-Agent header. Some authorities (e.g. api.weather.gov) request a descriptive UA; a bare/default agent may be throttled.

## `timeoutSecs` (type: `integer`):

Per-request timeout in seconds for fetching a feed or CAP document.

## Actor input object example

```json
{
  "startUrl": "https://api.weather.gov/alerts/active",
  "mode": "feed",
  "status": "Actual",
  "severity": "",
  "urgency": "",
  "certainty": "",
  "maxRecords": 1000,
  "timeoutSecs": 60
}
```

# 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 = {
    "startUrl": "https://api.weather.gov/alerts/active"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamule/cap-alert-extractor").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 = { "startUrl": "https://api.weather.gov/alerts/active" }

# Run the Actor and wait for it to finish
run = client.actor("datamule/cap-alert-extractor").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 '{
  "startUrl": "https://api.weather.gov/alerts/active"
}' |
apify call datamule/cap-alert-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CAP Alert Extractor (OASIS CAP 1.2 emergency alerts)",
        "description": "Point at ANY CAP alerting authority (US NWS, UN GDACS, Canada NAAD, PH PAGASA, NZ MetService + more in the WMO Register) and extract OASIS CAP 1.2 alerts as flat rows. Auto-decodes GeoJSON, inline CAP-XML feeds and Atom/RSS-linked CAP docs. One row per alert x info-language x area, with geometry.",
        "version": "0.1",
        "x-build-id": "gddiiQ5ZPAhsgoIiw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamule~cap-alert-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamule-cap-alert-extractor",
                "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/datamule~cap-alert-extractor/runs": {
            "post": {
                "operationId": "runs-sync-datamule-cap-alert-extractor",
                "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/datamule~cap-alert-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-datamule-cap-alert-extractor",
                "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": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Start URL (CAP feed or document)",
                        "type": "string",
                        "description": "A CAP alerting-authority source URL. In 'feed' mode: a GeoJSON alerts endpoint (US NWS https://api.weather.gov/alerts/active), a CAP-XML RSS feed of inline alerts (UN GDACS https://www.gdacs.org/xml/gdacs_cap.xml), or an Atom/RSS feed whose entries link to CAP docs (Canada NAAD https://rss.naad-adna.pelmorex.com/, PH PAGASA https://publicalert.pagasa.dost.gov.ph/feeds/, NZ MetService https://alerts.metservice.com/cap/rss). In 'alert' mode: a single CAP XML document URL. The serialization is auto-detected. Discover more authorities in the WMO Register of Alerting Authorities."
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "feed",
                            "alert"
                        ],
                        "type": "string",
                        "description": "'feed' (default) lists the current alerts from a feed/index (auto-detecting GeoJSON, an inline-CAP-XML feed, or an Atom/RSS feed that links to CAP docs). 'alert' parses ONE CAP XML document (startUrl points straight at a single <alert>) into its info/area rows.",
                        "default": "feed"
                    },
                    "status": {
                        "title": "Status filter",
                        "enum": [
                            "Actual",
                            "Exercise",
                            "System",
                            "Test",
                            "Draft",
                            ""
                        ],
                        "type": "string",
                        "description": "Only emit alerts with this CAP <status>. Default 'Actual' so Test/Exercise/Draft messages are never surfaced as real warnings. Set to empty to keep every status. Alerts that omit <status> are kept.",
                        "default": "Actual"
                    },
                    "severity": {
                        "title": "Severity filter (optional)",
                        "enum": [
                            "",
                            "Extreme",
                            "Severe",
                            "Moderate",
                            "Minor",
                            "Unknown"
                        ],
                        "type": "string",
                        "description": "Only emit rows whose CAP <severity> matches (case-insensitive). Leave empty for all severities.",
                        "default": ""
                    },
                    "urgency": {
                        "title": "Urgency filter (optional)",
                        "enum": [
                            "",
                            "Immediate",
                            "Expected",
                            "Future",
                            "Past",
                            "Unknown"
                        ],
                        "type": "string",
                        "description": "Only emit rows whose CAP <urgency> matches (case-insensitive). Leave empty for all.",
                        "default": ""
                    },
                    "certainty": {
                        "title": "Certainty filter (optional)",
                        "enum": [
                            "",
                            "Observed",
                            "Likely",
                            "Possible",
                            "Unlikely",
                            "Unknown"
                        ],
                        "type": "string",
                        "description": "Only emit rows whose CAP <certainty> matches (case-insensitive). Leave empty for all.",
                        "default": ""
                    },
                    "maxRecords": {
                        "title": "Max records",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after emitting this many (alert × info × area) rows.",
                        "default": 1000
                    },
                    "userAgent": {
                        "title": "User-Agent (optional)",
                        "type": "string",
                        "description": "Override the default User-Agent header. Some authorities (e.g. api.weather.gov) request a descriptive UA; a bare/default agent may be throttled."
                    },
                    "timeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "type": "integer",
                        "description": "Per-request timeout in seconds for fetching a feed or CAP document.",
                        "default": 60
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
