# ImportYeti Trade Intelligence Scraper (`automation-lab/importyeti-trade-intelligence-scraper`) Actor

Extract public ImportYeti company, supplier, shipment, HS-code, trade-lane, weight, TEU, product, and bill-of-lading intelligence.

- **URL**: https://apify.com/automation-lab/importyeti-trade-intelligence-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

from $0.01 / 1,000 item 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.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

## ImportYeti Trade Intelligence Scraper

Turn public ImportYeti company profiles into analysis-ready company, supplier, and shipment records.

Use company profile URLs or slugs to collect supplier relationships, shipment totals, origins, HS codes, product descriptions, trade lanes, weights, TEU trends, and recent bills of lading.

The actor is designed for repeatable sourcing research and supply-chain monitoring. It uses the public ImportYeti JSON data surface, requires no account, and returns linked records that work in CSV, JSON, Excel, APIs, and data warehouses.

### What does ImportYeti Trade Intelligence Scraper do?

The actor extracts three linked record types:

- 🏢 Company profiles
- 🏭 Supplier relationships
- 🚢 Recent shipments

Every row includes a `recordType`, `companySlug`, `companyName`, `sourceUrl`, and `scrapedAt` value.

This makes mixed exports easy to filter while preserving joins between companies, suppliers, and shipments.

### Who is it for?

#### Sourcing teams

- Discover established suppliers behind known importers.
- Compare supplier shipment activity.
- Review product descriptions and HS-code categories.

#### Import and export analysts

- Track shipment, weight, and TEU trends.
- Analyze origin countries and trade lanes.
- Monitor first and latest shipment dates.

#### Ecommerce operators

- Research supply chains behind retailers and brands.
- Find product and supplier patterns.
- Build recurring competitor intelligence feeds.

#### B2B researchers

- Enrich company lists with trade evidence.
- Identify active supplier relationships.
- Export structured records to a CRM or warehouse.

### Why use this actor?

- ✅ No ImportYeti login or API key required
- ✅ URL and slug inputs
- ✅ Company, supplier, and shipment records
- ✅ Bounded output controls
- ✅ Monthly and quarterly trends
- ✅ HS codes and product descriptions
- ✅ Source URLs on every result
- ✅ Scheduled monitoring on Apify

### Data you can extract

| Group | Example fields |
|---|---|
| Company | name, aliases, address, country, website, phone |
| Trade totals | shipments, first date, latest date, shipping cost |
| Trends | monthly shipments, weight, TEU, China metrics |
| Suppliers | name, address, country, shipment share, 12-month volume |
| Products | descriptions, HS chapters, HS codes |
| Shipments | bill numbers, date, quantity, weight, TEU |
| Parties | shipper, consignee, notify party |
| Provenance | source URL, slug, extraction timestamp |

### How to use it

1. Open the actor input page.
2. Add one or more ImportYeti company profile URLs.
3. Set supplier and shipment limits.
4. Choose whether to preserve time series and HS-code details.
5. Click **Start**.
6. Export the dataset in your preferred format.

A low-cost first run can use one company with ten suppliers and ten shipments.

### Input

#### Company profile URLs

Use URLs such as:

```text
https://www.importyeti.com/company/wal-mart
````

#### Company slugs

You can also provide the final path segment:

```text
wal-mart
```

#### Output limits

- `maxSuppliersPerCompany`: 0 to 50
- `maxShipmentsPerCompany`: 0 to 50

#### Detail options

- `includeTimeSeries`: preserve monthly and quarterly metrics
- `includeHsCodes`: preserve HS-code arrays
- `requestDelayMs`: delay between company requests

### Input example

```json
{
  "companyUrls": [
    "https://www.importyeti.com/company/wal-mart"
  ],
  "companySlugs": [],
  "maxSuppliersPerCompany": 10,
  "maxShipmentsPerCompany": 10,
  "includeTimeSeries": true,
  "includeHsCodes": true,
  "requestDelayMs": 500
}
```

### Output

Company example:

```json
{
  "recordType": "company",
  "companySlug": "wal-mart",
  "companyName": "Wal Mart",
  "totalShipments": 690729,
  "countryCode": "US",
  "firstShipmentDate": "01/01/2015",
  "sourceUrl": "https://www.importyeti.com/company/wal-mart"
}
```

Supplier example:

```json
{
  "recordType": "supplier",
  "companySlug": "wal-mart",
  "supplierName": "Example Supplier",
  "supplierCountryCode": "CN",
  "shipments12Months": 1450,
  "productDescriptions": ["Example product"]
}
```

Shipment example:

```json
{
  "recordType": "shipment",
  "companySlug": "wal-mart",
  "shipmentDate": "08/07/2026",
  "billOfLading": "EXAMPLE123",
  "originCountry": "Mexico",
  "hsCode": "852872"
}
```

### How much does it cost to scrape ImportYeti trade data?

This actor uses pay-per-event pricing.

- A small start event covers run initialization.
- Each saved dataset record is charged as one item.
- Apify plan tiers receive volume-adjusted item prices.

Your final cost depends on the number of companies and the supplier and shipment limits.

Use smaller limits when testing a workflow.

### Sourcing workflow

1. Start with a list of target importer URLs.
2. Extract leading suppliers.
3. Filter suppliers by origin country.
4. Rank relationships by recent shipment activity.
5. Review products and HS chapters.
6. Send shortlisted suppliers to qualification.

### Monitoring workflow

Schedule the actor weekly or monthly.

Compare these fields over time:

- `shipments12Months`
- `shipmentsPrevious12Months`
- `latestShipmentDate`
- `isNewSupplier`
- `monthlyTimeSeries`
- `quarterlyTimeSeries`

Store snapshots in Google Sheets, a database, or an Apify integration.

### Tips for reliable results

- Copy the canonical public company profile URL.
- Keep the default request delay for large batches.
- Start with one known company before uploading a long list.
- Disable time series when compact payloads matter more than history.
- Use `recordType` to split rows after export.
- Deduplicate recurring snapshots by company, record type, and entity identifier.

### Integrations

#### Google Sheets

Send scheduled exports to a shared sourcing sheet.

#### Webhooks

Trigger downstream enrichment when a run finishes.

#### Zapier and Make

Route new supplier rows into a CRM or review queue.

#### Data warehouses

Load JSON or CSV exports into BigQuery, Snowflake, or PostgreSQL.

#### AI analysis

Feed structured trade records to an LLM for supplier summaries and change detection.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/importyeti-trade-intelligence-scraper').call({
  companySlugs: ['wal-mart'],
  maxSuppliersPerCompany: 10,
  maxShipmentsPerCompany: 10
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/importyeti-trade-intelligence-scraper').call(run_input={
    'companySlugs': ['wal-mart'],
    'maxSuppliersPerCompany': 10,
    'maxShipmentsPerCompany': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~importyeti-trade-intelligence-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"companySlugs":["wal-mart"],"maxSuppliersPerCompany":10,"maxShipmentsPerCompany":10}'
```

### Use with Apify MCP

Connect from Claude Code with the hosted Apify MCP endpoint:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/importyeti-trade-intelligence-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server to the client's MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/importyeti-trade-intelligence-scraper"
    }
  }
}
```

The MCP client will prompt you to authenticate with Apify when needed. Example prompts:

- “Extract the leading suppliers for this ImportYeti company URL.”
- “Summarize recent shipment trends and origin countries.”
- “Compare 12-month supplier activity and flag new suppliers.”

### Record linking

All records include:

- `companySlug`
- `companyName`
- `sourceUrl`
- `scrapedAt`

Supplier rows add `supplierKey` where available.

Shipment rows add bill-of-lading identifiers and supplier URLs where available.

### Error handling

Invalid slugs are rejected before requests are made.

Missing companies are logged and skipped so other valid companies can continue.

Transient rate limits and server errors use bounded exponential backoff.

The run fails when no records can be produced.

### Legality and responsible use

ImportYeti presents public trade information derived from shipment records.

Use the actor only for lawful purposes.

Respect applicable laws, contractual duties, privacy requirements, and the source website’s terms.

Do not use results for harassment, discrimination, or unlawful profiling.

### FAQ

#### Does this actor require an ImportYeti account?

No. It uses the anonymously accessible public company data surface.

#### Can I search by arbitrary company name?

Not currently. Use a known company profile URL or slug. This avoids relying on an unproven search endpoint.

#### Why are there multiple record types?

A company profile contains distinct company, supplier, and shipment facts. `recordType` keeps one export easy to filter and join.

#### Why did my run return no data?

Confirm the URL opens a company profile and contains `/company/<slug>`. Try the slug directly if the URL has tracking parameters.

#### How can I reduce output size?

Lower supplier and shipment limits, or disable time series and HS-code details.

#### Can I schedule the actor?

Yes. Use Apify schedules and integrations for recurring supply-chain monitoring.

### Related scrapers

Explore other business and lead intelligence tools from [automation-lab](https://apify.com/automation-lab).

Combine this actor with company enrichment, website technology, email discovery, or business directory actors when building a broader sourcing workflow.

### Support

If a public ImportYeti profile works in a browser but fails here, include the profile URL and run ID in an Apify issue.

Avoid sharing confidential downstream data.

We use reproducible run evidence to investigate source changes and extraction problems.

# Actor input Schema

## `companyUrls` (type: `array`):

ImportYeti URLs such as https://www.importyeti.com/company/wal-mart.

## `companySlugs` (type: `array`):

Optional slugs copied from the end of ImportYeti profile URLs, for example wal-mart.

## `maxSuppliersPerCompany` (type: `integer`):

Save up to this many leading supplier relationships for each company.

## `maxShipmentsPerCompany` (type: `integer`):

Save up to this many recent bill-of-lading shipment records for each company.

## `includeTimeSeries` (type: `boolean`):

Preserve monthly company and quarterly supplier shipment, weight, and TEU trends.

## `includeHsCodes` (type: `boolean`):

Preserve company HS-code mix and supplier HS-code chapters.

## `requestDelayMs` (type: `integer`):

Conservative delay between public API requests. Increase this if the source rate-limits a large batch.

## Actor input object example

```json
{
  "companyUrls": [
    "https://www.importyeti.com/company/wal-mart"
  ],
  "companySlugs": [],
  "maxSuppliersPerCompany": 10,
  "maxShipmentsPerCompany": 10,
  "includeTimeSeries": true,
  "includeHsCodes": true,
  "requestDelayMs": 500
}
```

# 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 = {
    "companyUrls": [
        "https://www.importyeti.com/company/wal-mart"
    ],
    "maxSuppliersPerCompany": 10,
    "maxShipmentsPerCompany": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/importyeti-trade-intelligence-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 = {
    "companyUrls": ["https://www.importyeti.com/company/wal-mart"],
    "maxSuppliersPerCompany": 10,
    "maxShipmentsPerCompany": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/importyeti-trade-intelligence-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 '{
  "companyUrls": [
    "https://www.importyeti.com/company/wal-mart"
  ],
  "maxSuppliersPerCompany": 10,
  "maxShipmentsPerCompany": 10
}' |
apify call automation-lab/importyeti-trade-intelligence-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ImportYeti Trade Intelligence Scraper",
        "description": "Extract public ImportYeti company, supplier, shipment, HS-code, trade-lane, weight, TEU, product, and bill-of-lading intelligence.",
        "version": "0.1",
        "x-build-id": "aX9TbENccF8LoCEHc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~importyeti-trade-intelligence-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-importyeti-trade-intelligence-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~importyeti-trade-intelligence-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-importyeti-trade-intelligence-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~importyeti-trade-intelligence-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-importyeti-trade-intelligence-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",
                "properties": {
                    "companyUrls": {
                        "title": "Company profile URLs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "ImportYeti URLs such as https://www.importyeti.com/company/wal-mart.",
                        "default": [
                            "https://www.importyeti.com/company/wal-mart"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "companySlugs": {
                        "title": "Company slugs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Optional slugs copied from the end of ImportYeti profile URLs, for example wal-mart.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSuppliersPerCompany": {
                        "title": "Maximum suppliers per company",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Save up to this many leading supplier relationships for each company.",
                        "default": 50
                    },
                    "maxShipmentsPerCompany": {
                        "title": "Maximum recent shipments per company",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Save up to this many recent bill-of-lading shipment records for each company.",
                        "default": 50
                    },
                    "includeTimeSeries": {
                        "title": "Include trade time series",
                        "type": "boolean",
                        "description": "Preserve monthly company and quarterly supplier shipment, weight, and TEU trends.",
                        "default": true
                    },
                    "includeHsCodes": {
                        "title": "Include HS-code details",
                        "type": "boolean",
                        "description": "Preserve company HS-code mix and supplier HS-code chapters.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between companies (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Conservative delay between public API requests. Increase this if the source rate-limits a large batch.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```