# OFAC Sanctions List Export Scraper (`automation-lab/ofac-sanctions-list-export-scraper`) Actor

Export official OFAC SDN and consolidated sanctions lists with aliases, addresses, programs, and source metadata for AML/KYC workflows.

- **URL**: https://apify.com/automation-lab/ofac-sanctions-list-export-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## OFAC Sanctions List Export Scraper

Export and normalize public OFAC sanctions lists for AML, KYC, procurement, compliance, and risk monitoring workflows.

The actor downloads official OFAC CSV export files, joins primary records with aliases and addresses, and outputs clean dataset rows that are ready for screening, enrichment, or change-detection pipelines.

### What does OFAC Sanctions List Export Scraper do?

This actor fetches public OFAC sanctions data from the official OFAC sanctions list service.

It currently supports:

- Specially Designated Nationals (SDN) primary export
- SDN aliases / alternate names
- SDN address records
- Consolidated non-SDN primary export
- Consolidated non-SDN aliases
- Consolidated non-SDN address records

Each output item represents one sanctions entity.

Aliases and addresses are attached to the entity as nested arrays.

The output also includes source URLs, source digest headers, Last-Modified metadata, and the scrape timestamp.

### Who is it for?

This actor is for compliance, AML, legal, procurement, and data teams.

Typical users include:

- Fintech compliance teams screening customers and counterparties
- KYC vendors enriching onboarding workflows
- Procurement teams monitoring vendors and beneficial owners
- Legal teams checking entities against sanctions programs
- Data engineers building sanctions snapshots in warehouses
- Risk teams comparing current and previous list exports

Use this actor when you need repeatable OFAC export data in Apify datasets, APIs, or integrations.

### Why use it?

OFAC provides public export files, but teams still need structured rows that are easy to automate.

This actor helps by:

- Downloading the relevant public files in one run
- Normalizing CSV rows into JSON records
- Joining aliases and addresses to the primary entity
- Preserving official OFAC UID values
- Capturing source metadata for audit trails
- Supporting small smoke tests and larger exports

### Data you can extract

| Field | Description |
| --- | --- |
| `uid` | Official OFAC UID from the source file |
| `list` | `sdn` or `consolidated` |
| `sourceListName` | Human-readable list name |
| `name` | Entity, vessel, organization, or individual name |
| `entityType` | OFAC entity type when provided |
| `programs` | Sanctions programs or list codes |
| `remarks` | OFAC remarks such as DOB, POB, or notes |
| `aliases` | Alternate names / aka records |
| `addresses` | Address records with country and full address |
| `sourceDigest` | Digest header from the source export response |
| `sourceLastModified` | Last-Modified header from the source export response |
| `scrapedAt` | Actor run timestamp |

### How much does it cost to export OFAC sanctions lists?

The actor uses pay-per-event pricing.

There is a small start charge per run and a tiered per-entity charge for records emitted to the dataset.

The exact live prices are shown on the Apify Store pricing tab.

For testing, keep `maxItems` low.

For full snapshots, increase `maxItems` high enough to include all selected lists.

### Input configuration

The input has only a few practical options.

```json
{
  "lists": ["sdn"],
  "maxItems": 200,
  "includeAliases": true,
  "includeAddresses": true,
  "includeRawFields": false
}
````

#### `lists`

Choose one or both supported export groups.

- `sdn` downloads SDN primary, alias, and address CSV files.
- `consolidated` downloads consolidated non-SDN primary, alias, and address CSV files.

#### `maxItems`

Limits the total number of entity rows emitted across all selected lists.

Use a small value for quick tests.

Use a large value for complete exports.

#### `includeAliases`

When enabled, each entity includes an `aliases` array.

Each alias contains an alias ID, alias type, name, and optional remarks.

#### `includeAddresses`

When enabled, each entity includes an `addresses` array.

Each address contains the OFAC address ID, address lines, country, and normalized full address.

#### `includeRawFields`

Enable this only for audits or troubleshooting.

It adds the raw primary CSV fields as `rawFields`.

### Output example

```json
{
  "uid": "306",
  "list": "sdn",
  "sourceListName": "Specially Designated Nationals (SDN)",
  "name": "BANCO NACIONAL DE CUBA",
  "entityType": null,
  "programs": ["CUBA"],
  "remarks": "a.k.a. 'BNC'.",
  "aliasCount": 1,
  "addressCount": 3,
  "sourceUrls": ["https://sanctionslistservice.ofac.treas.gov/api/PublicationPreview/exports/SDN.CSV"],
  "scrapedAt": "2026-06-29T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Choose SDN, consolidated, or both lists.
3. Set `maxItems`.
4. Keep aliases and addresses enabled for screening use cases.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Practical workflows

Common workflows include:

- Daily sanctions snapshot export
- Vendor list screening enrichment
- Customer onboarding watchlist checks
- Internal warehouse refreshes
- OFAC change monitoring using `sourceDigest`
- Legal review exports for specific programs

### Integrations

You can send the dataset to:

- Google Sheets
- BigQuery
- Snowflake
- S3-compatible storage
- Zapier or Make
- Internal compliance APIs
- Apify webhooks

For change monitoring, store the previous run's digest and compare it with the current run.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ofac-sanctions-list-export-scraper').call({
  lists: ['sdn', 'consolidated'],
  maxItems: 1000,
  includeAliases: true,
  includeAddresses: true
});

console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/ofac-sanctions-list-export-scraper').call(run_input={
    'lists': ['sdn'],
    'maxItems': 500,
    'includeAliases': True,
    'includeAddresses': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~ofac-sanctions-list-export-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"lists":["sdn"],"maxItems":200,"includeAliases":true,"includeAddresses":true}'
```

### MCP usage

Use Apify MCP when you want Claude Desktop, Claude Code, or another MCP client to run this actor.

Add the actor tool in Claude Code:

```bash
claude mcp add apify-ofac-sanctions https://mcp.apify.com/?tools=automation-lab/ofac-sanctions-list-export-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-ofac-sanctions": {
      "url": "https://mcp.apify.com/?tools=automation-lab/ofac-sanctions-list-export-scraper"
    }
  }
}
```

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/ofac-sanctions-list-export-scraper
```

Example prompts:

- "Export the first 500 OFAC SDN entities with aliases."
- "Run the OFAC sanctions export and summarize how many entities have addresses."
- "Fetch consolidated non-SDN records and prepare a CSV for compliance review."

### Data freshness

The actor downloads files from OFAC during each run.

Freshness therefore depends on the official OFAC export endpoint and its current published files.

Use `sourceLastModified` and `sourceDigest` to record which source version was used.

### Limitations

The actor normalizes OFAC export files; it does not make legal decisions.

It does not replace a sanctions screening engine.

It does not score matches, resolve identities, or adjudicate false positives.

OFAC source formatting can change, so downstream workflows should monitor schema changes.

### Troubleshooting

If a run returns fewer records than expected, check `maxItems` first.

If aliases or addresses are missing, confirm `includeAliases` and `includeAddresses` are enabled.

If source metadata changes, compare `sourceDigest` and `sourceLastModified` across runs.

If OFAC is temporarily unavailable, retry later; no proxy or browser is normally required.

### Legality

OFAC sanctions export files are public government data, but sanctions compliance is a regulated workflow.

Use the actor as a data collection and normalization tool, not as legal advice or screening adjudication.

### Is it legal to scrape OFAC sanctions data?

OFAC sanctions export files are public government data.

You are responsible for using the data lawfully and for complying with sanctions, privacy, procurement, and record-retention rules that apply to your organization.

Consult qualified counsel for legal interpretations.

### Related scrapers

Related Automation Labs actors for compliance and government-data workflows:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/google-search-results-scraper

More sanctions, procurement, and compliance actors may be added as the portfolio grows.

### FAQ

#### Can this actor export the full OFAC SDN list?

Yes. Set `maxItems` high enough to include all entities.

#### Does it include aliases?

Yes. Keep `includeAliases` enabled.

#### Does it include addresses?

Yes. Keep `includeAddresses` enabled.

#### Does it use a browser?

No. It downloads official CSV files over HTTP.

#### Does it use proxies?

No proxy is required for the official public OFAC export endpoint.

#### Can I use this for screening?

You can use it as a data input for screening workflows, but matching and legal adjudication must be handled by your compliance process.

#### How do I detect list changes?

Compare `sourceDigest`, `sourceLastModified`, dataset counts, or the records themselves across scheduled runs.

#### What happens if OFAC changes the CSV format?

The actor may need an update. Keep an eye on logs and output fields if OFAC announces format changes.

### Support

If the actor fails or the output does not match the current OFAC export files, open an Apify issue with the run ID and your input.

Include whether you selected SDN, consolidated, or both lists.

### Changelog

Initial version supports official OFAC SDN and consolidated non-SDN CSV exports with aliases, addresses, programs, and source metadata.

# Actor input Schema

## `lists` (type: `array`):

Choose which public OFAC export files to download and normalize. SDN is the main Specially Designated Nationals list; consolidated includes non-SDN lists.

## `maxItems` (type: `integer`):

Maximum sanctions entity records to emit across all selected lists. Use a small value for testing or a large value for full exports.

## `includeAliases` (type: `boolean`):

Attach OFAC alternate names / aka records to each entity.

## `includeAddresses` (type: `boolean`):

Attach OFAC address records to each entity.

## `includeRawFields` (type: `boolean`):

Include the raw primary CSV row fields for audits or schema troubleshooting.

## Actor input object example

```json
{
  "lists": [
    "sdn"
  ],
  "maxItems": 20,
  "includeAliases": true,
  "includeAddresses": true,
  "includeRawFields": false
}
```

# Actor output Schema

## `overview` (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 = {
    "lists": [
        "sdn"
    ],
    "maxItems": 20,
    "includeAliases": true,
    "includeAddresses": true,
    "includeRawFields": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ofac-sanctions-list-export-scraper").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 = {
    "lists": ["sdn"],
    "maxItems": 20,
    "includeAliases": True,
    "includeAddresses": True,
    "includeRawFields": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ofac-sanctions-list-export-scraper").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 '{
  "lists": [
    "sdn"
  ],
  "maxItems": 20,
  "includeAliases": true,
  "includeAddresses": true,
  "includeRawFields": false
}' |
apify call automation-lab/ofac-sanctions-list-export-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/ofac-sanctions-list-export-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OFAC Sanctions List Export Scraper",
        "description": "Export official OFAC SDN and consolidated sanctions lists with aliases, addresses, programs, and source metadata for AML/KYC workflows.",
        "version": "0.1",
        "x-build-id": "6BSVefa7WRzGproiW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ofac-sanctions-list-export-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ofac-sanctions-list-export-scraper",
                "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/automation-lab~ofac-sanctions-list-export-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ofac-sanctions-list-export-scraper",
                "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/automation-lab~ofac-sanctions-list-export-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ofac-sanctions-list-export-scraper",
                "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": [
                    "lists",
                    "maxItems"
                ],
                "properties": {
                    "lists": {
                        "title": "Sanctions lists to export",
                        "type": "array",
                        "description": "Choose which public OFAC export files to download and normalize. SDN is the main Specially Designated Nationals list; consolidated includes non-SDN lists.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "sdn",
                                "consolidated"
                            ],
                            "enumTitles": [
                                "SDN list",
                                "Consolidated non-SDN lists"
                            ]
                        },
                        "default": [
                            "sdn"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum entities",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum sanctions entity records to emit across all selected lists. Use a small value for testing or a large value for full exports.",
                        "default": 20
                    },
                    "includeAliases": {
                        "title": "Include aliases",
                        "type": "boolean",
                        "description": "Attach OFAC alternate names / aka records to each entity.",
                        "default": true
                    },
                    "includeAddresses": {
                        "title": "Include addresses",
                        "type": "boolean",
                        "description": "Attach OFAC address records to each entity.",
                        "default": true
                    },
                    "includeRawFields": {
                        "title": "Include raw CSV fields",
                        "type": "boolean",
                        "description": "Include the raw primary CSV row fields for audits or schema troubleshooting.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
