# ImportYeti Scraper (`fetch_cat/importyeti-scraper`) Actor

Scrape public ImportYeti company and supplier search results with shipment counts, addresses, recency signals, and source URLs.

- **URL**: https://apify.com/fetch\_cat/importyeti-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 result extracteds

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/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

## ImportYeti Scraper

Extract public ImportYeti company and supplier search results for sourcing, lead generation, and trade intelligence workflows.

Use this Actor to turn ImportYeti searches into structured CSV, JSON, Excel, API, or webhook-ready records with shipment counts, addresses, countries, recency signals, and source URLs.

### Who is this for?

- **Sourcing teams** looking for supplier and importer signals from public customs data.
- **Private-label and ecommerce sellers** researching brands, suppliers, and shipment volume.
- **Import/export sales teams** building targeted lead lists from trade activity.
- **Freight and logistics analysts** monitoring company and supplier shipment recency.
- **Market researchers** comparing public ImportYeti entity records across keywords.

### At a glance

- **Primary job**: Search ImportYeti for public company and supplier records.
- **Input**: Enter a keyword such as a brand, supplier, product, or company name.
- **Output**: One dataset row per public ImportYeti result.
- **Best for**: Supplier discovery, import/export sales, private-label sourcing, logistics research, and recurring market monitoring.

### Common use cases

- **Supplier discovery**: Search a product or brand keyword and export companies, suppliers, shipment counts, addresses, and ImportYeti URLs.
- **Lead qualification**: Use `minShipments` to focus on entities with meaningful shipment activity.
- **Competitor supply-chain monitoring**: Schedule repeat runs for brand queries and compare shipment recency over time.
- **Workflow automation**: Send dataset results to a CRM, spreadsheet, warehouse, or enrichment workflow with Apify integrations.

### Input recipes

- **Small smoke test**: `query="nike"`, `maxItems=10`.
- **Supplier discovery**: `query="electronics"`, `minShipments=50`, `maxItems=25`.
- **Recent supplier leads**: `query="apparel"`, `type="supplier"`, `mostRecentShipment="last_24_months"`.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query` | Search keyword used for the run. |
| `searchType` | ImportYeti search mode (`companies` in v1). |
| `entityName` | Company or supplier name. |
| `entityType` | ImportYeti result type, such as `company` or `supplier`. |
| `sourceUrl` | Public ImportYeti result/profile URL. |
| `country` | Country code shown by ImportYeti. |
| `address` | Public address shown in search results. |
| `totalShipments` | Total shipment count shown by ImportYeti. |
| `mostRecentShipment` | Most recent shipment date shown by ImportYeti. |
| `otherAddressesCount` | Count of additional known addresses when visible. |
| `otherNamesCount` | Count of additional known names when visible. |
| `topSuppliers`, `topCustomers`, `hsCodes` | Reserved arrays for future profile-detail expansion. |
| `status`, `error` | Per-record status fields. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Search query | `query` | Brand, company, supplier, product, or keyword. | `nike` |
| Search type | `searchType` | ImportYeti search tab. V1 supports `companies`. | `companies` |
| Entity type | `type` | Keep all results or only companies/suppliers. | `supplier` |
| Most recent shipment | `mostRecentShipment` | Keep records with recent shipment dates. | `last_24_months` |
| Minimum shipments | `minShipments` | Filter out low-volume entities. | `50` |
| Maximum results | `maxItems` | Limit saved rows and cost. | `10` |
| Proxy configuration | `proxyConfiguration` | Optional Apify Proxy settings if ImportYeti blocks direct access. | `{ "useApifyProxy": false }` |

### Example input

```json
{
  "query": "nike",
  "searchType": "companies",
  "type": "any",
  "mostRecentShipment": "any",
  "minShipments": 0,
  "maxItems": 10,
  "proxyConfiguration": { "useApifyProxy": false }
}
````

### Example output

```json
{
  "query": "nike",
  "searchType": "companies",
  "entityName": "Nike Usa",
  "entityType": "company",
  "sourceUrl": "https://www.importyeti.com/company/nike-usa",
  "country": "US",
  "address": "Beaverton, Or 97005, Us",
  "totalShipments": 139845,
  "mostRecentShipment": "11/07/2026",
  "topSuppliers": [],
  "topCustomers": [],
  "hsCodes": [],
  "shipmentCount12m": null,
  "otherAddressesCount": 37,
  "otherNamesCount": 24,
  "scrapedAt": "2026-07-15T08:00:00.000Z",
  "status": "ok",
  "error": null
}
```

### Pricing

| Event | Price | Charged when |
| --- | --- | --- |
| Run start | `$0.005` per run | Once when the Actor starts. |
| Result saved | `$0.00003666` per saved result at BRONZE tier | Each successful ImportYeti result is saved. |

Tier discounts are configured on Apify: FREE `$0.000042159`, BRONZE `$0.00003666`, SILVER `$0.000028594`, GOLD `$0.000021996`, PLATINUM `$0.000014664`, DIAMOND `$0.000010265` per result.

### Tips for best results

- **Start small**: Use `maxItems: 10` until you confirm the query returns the right market segment.
- **Use focused keywords**: Brand, supplier, or product terms usually produce cleaner results than broad industry words.
- **Avoid empty-success assumptions**: The Actor fails when ImportYeti returns no usable records after filters.
- **Respect public data boundaries**: This Actor extracts public ImportYeti search data only; it does not use private accounts, cookies, or paid ImportYeti API credentials.

### API usage

Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/importyeti-scraper').call({
  query: 'nike',
  maxItems: 10,
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/importyeti-scraper').call(run_input={
    'query': 'nike',
    'maxItems': 10,
})
print(run['defaultDatasetId'])
```

cURL:

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~importyeti-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"nike","maxItems":10}'
```

### MCP and AI agents

You can use this Actor from AI agents through Apify MCP or the Apify API. Add the Apify MCP server to Claude CLI:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/importyeti-scraper
```

Example MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "fetch_cat/importyeti-scraper"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

Example prompts showing MCP usage for AI agents:

- **Supplier research**: "Use ImportYeti Scraper to find supplier records for electronics with more than 50 shipments. Return entity name, source URL, and shipment count."
- **Brand monitoring**: "Run ImportYeti Scraper for Nike with 25 results and summarize companies with the newest shipment dates."
- **CRM enrichment**: "Search ImportYeti for apparel suppliers, then format the results as CRM leads with `entityName`, `sourceUrl`, and `totalShipments`."

Typical agent workflows include CRM enrichment, recurring monitoring, and sourcing research where an agent compares new shipment recency values with earlier datasets.

### Responsible use

ImportYeti Scraper collects public search-result data only. Do not use it for private accounts, login-only data, paid ImportYeti API credentials, or contact enrichment that is not visible in public ImportYeti records. Check that your use complies with ImportYeti terms and applicable laws.

### FAQ

**Does this scrape bill-of-lading detail rows?**\
Not in v1. This release focuses on public search-result entities. Profile and BOL detail expansion is deferred until separately validated.

**Why did my filtered run fail with zero results?**\
The Actor treats zero usable records after filters as a failure so you do not mistake a blocked or over-filtered run for valid empty output. Lower `minShipments`, broaden the query, or increase `maxItems`.

**Can I use proxies?**\
Yes. Direct HTTP is the default because the public search API is currently reachable. Enable Apify Proxy if your run receives edge blocks.

**Can I schedule recurring monitoring?**\
Yes. Schedule the Actor in Apify and compare exported datasets by `query`, `sourceUrl`, and `mostRecentShipment`.

### Related Actors

- [Google Search Results Scraper](https://apify.com/fetch_cat/google-search-results-scraper) for broader web discovery workflows.
- [Website Content Crawler Lite](https://apify.com/fetch_cat/website-content-crawler-lite) for extracting page content from public URLs.
- [Bulk URL Status Checker](https://apify.com/fetch_cat/bulk-url-status-checker) for validating exported ImportYeti source URLs.

### Support

If you see blocked pages, missing fields, or a query that should return public ImportYeti results but does not, open an issue from the Actor page and include:

- **Input JSON** used for the run.
- **Expected output** you thought should be returned.
- **Actual output** or error message.
- **Reproducible public URL** from ImportYeti when possible.
- **Run ID** so the logs and dataset can be inspected.

# Actor input Schema

## `query` (type: `string`):

Company, supplier, product, brand, city, or HS-code keyword to search on ImportYeti.

## `searchType` (type: `string`):

ImportYeti search tab to use. Company/supplier search is enabled first; other tabs are validated as support is proven.

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

Optional type filter when supported by ImportYeti search results.

## `mostRecentShipment` (type: `string`):

Optional recency filter to apply when visible in the public search route.

## `minShipments` (type: `integer`):

Optional lower bound for total shipments when the value is visible in search results.

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

Maximum number of successful entity records to save.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Direct HTTP is used by default; enable proxy if ImportYeti blocks your run.

## Actor input object example

```json
{
  "query": "nike",
  "searchType": "companies",
  "type": "any",
  "mostRecentShipment": "any",
  "minShipments": 0,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "query": "nike",
    "searchType": "companies",
    "type": "any",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/importyeti-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 = {
    "query": "nike",
    "searchType": "companies",
    "type": "any",
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/importyeti-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 '{
  "query": "nike",
  "searchType": "companies",
  "type": "any",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/importyeti-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ImportYeti Scraper",
        "description": "Scrape public ImportYeti company and supplier search results with shipment counts, addresses, recency signals, and source URLs.",
        "version": "0.1",
        "x-build-id": "ah693qJHvwAqN9U6f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~importyeti-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-importyeti-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/fetch_cat~importyeti-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-importyeti-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/fetch_cat~importyeti-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-importyeti-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": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "minLength": 1,
                        "type": "string",
                        "description": "Company, supplier, product, brand, city, or HS-code keyword to search on ImportYeti."
                    },
                    "searchType": {
                        "title": "Search type",
                        "enum": [
                            "companies"
                        ],
                        "type": "string",
                        "description": "ImportYeti search tab to use. Company/supplier search is enabled first; other tabs are validated as support is proven.",
                        "default": "companies"
                    },
                    "type": {
                        "title": "Entity type filter",
                        "enum": [
                            "any",
                            "company",
                            "supplier"
                        ],
                        "type": "string",
                        "description": "Optional type filter when supported by ImportYeti search results.",
                        "default": "any"
                    },
                    "mostRecentShipment": {
                        "title": "Most recent shipment",
                        "enum": [
                            "any",
                            "last_12_months",
                            "last_24_months"
                        ],
                        "type": "string",
                        "description": "Optional recency filter to apply when visible in the public search route.",
                        "default": "any"
                    },
                    "minShipments": {
                        "title": "Minimum total shipments",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional lower bound for total shipments when the value is visible in search results.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of successful entity records to save.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Direct HTTP is used by default; enable proxy if ImportYeti blocks your run.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
