# Shopify Store Leads Scraper (`automation-lab/shopify-store-leads-scraper`) Actor

Discover Shopify merchant domains and enrich public storefronts with emails, phones, social links, popularity signals, and metadata for ecommerce lead generation.

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

## Pricing

from $0.47 / 1,000 shopify lead saveds

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

## Shopify Store Leads Scraper

Find Shopify merchant leads from public MyIP.ms data and enrich each storefront with public contact signals.

### What does Shopify Store Leads Scraper do?

Shopify Store Leads Scraper discovers websites hosted by Shopify and turns them into a clean lead dataset.
It starts from public MyIP.ms Shopify owner pages and extracts merchant domains, hosting metadata, popularity signals, emails, phone numbers, social profiles, and storefront metadata.

Use it when you need a repeatable way to build ecommerce prospect lists without copying tables by hand.

### Who is it for? Shopify lead generation teams

- 🧲 **B2B sales teams** looking for ecommerce merchants that may need apps, services, logistics, ads, or support.
- 🛠️ **Shopify app founders** searching for public storefronts to qualify for outbound campaigns.
- 📣 **Marketing agencies** building niche lists of direct-to-consumer brands.
- 📊 **Market researchers** studying Shopify adoption, merchant popularity, and store metadata.
- 🤝 **Partnership teams** finding stores with public social and contact information.

### Why use this actor?

- ✅ Public data source: MyIP.ms Shopify owner pages are visible without an account.
- ✅ HTTP-first implementation: no heavyweight browser is needed for discovery.
- ✅ Lead enrichment: visits public storefront, contact, and about pages.
- ✅ Skips failures per domain: one blocked store does not stop the full run.
- ✅ Clear provenance: every row includes the MyIP.ms source URL and source rank.

### What Shopify lead data can it extract?

| Field | Description |
| --- | --- |
| `domain` | Merchant domain from MyIP.ms |
| `url` | Normalized storefront URL |
| `emails` | Public email addresses found in storefront HTML |
| `phones` | Public phone-like contact numbers found in page text |
| `socialLinks` | Facebook, Instagram, LinkedIn, Pinterest, TikTok, Twitter/X, and YouTube links |
| `title` | Storefront page title |
| `description` | Storefront meta description |
| `ipAddress` | Website IP from MyIP.ms |
| `hostingOwner` | Hosting company / IP owner |
| `hostingCountry` | Hosting country |
| `hostingCity` | Hosting city, when MyIP.ms provides it |
| `worldSiteRank` | MyIP.ms world site popularity rank |
| `estimatedVisitorsPerDay` | MyIP.ms visitors-per-day estimate |
| `recordUpdatedAt` | MyIP.ms record update time |
| `shopifyDetected` | Whether Shopify markers are found in public HTML |
| `enrichmentStatus` | `success`, `partial`, `failed`, or `skipped` |

### How much does it cost to scrape Shopify store leads?

This actor uses pay-per-event pricing.
The initial lead event is designed around the ecommerce lead-generation baseline: about **$0.50 per 1,000 saved Shopify leads** before tier discounts.
A tiny start event is charged once per run.

You control cost with:

- `maxItems` for the number of leads saved.
- `enrichStorefronts` to enable or skip storefront contact discovery.
- `maxEnrichmentPagesPerStore` to limit contact/about page attempts.

### How to scrape Shopify store leads

1. Open the actor on Apify.
2. Keep the default MyIP.ms source URL or choose a starting page.
3. Set `maxItems` to a small number for your first run.
4. Leave `enrichStorefronts` enabled if you want emails, phones, and social links.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### `startPage`

The first MyIP.ms Shopify owner page number to crawl when no custom start URLs are supplied.
Page 1 contains the highest-ranked Shopify-hosted domains.

#### `maxPages`

How many consecutive source pages to try.
Keep this low for quick tests.

#### `maxItems`

The maximum number of Shopify lead rows to save.

#### `startUrls`

Optional direct MyIP.ms URLs.
Example:

```json
[
  { "url": "https://myip.ms/browse/sites/1/own/376714" }
]
````

#### `enrichStorefronts`

When enabled, the actor visits public storefront pages to find emails, phones, social links, titles, descriptions, and Shopify markers.

#### `maxEnrichmentPagesPerStore`

Controls how many pages are tried per store.
The actor checks common home, contact, and about URLs.

#### `requestTimeoutSecs`

Maximum request time for each page before the actor skips that page.

### Example input

```json
{
  "startUrls": [
    { "url": "https://myip.ms/browse/sites/1/own/376714" }
  ],
  "maxItems": 10,
  "enrichStorefronts": true,
  "maxEnrichmentPagesPerStore": 3,
  "requestTimeoutSecs": 20
}
```

### Example output

```json
{
  "domain": "example-shop.com",
  "url": "https://example-shop.com",
  "emails": ["support@example-shop.com"],
  "phones": ["+1 555-123-4567"],
  "socialLinks": {
    "instagram": "https://www.instagram.com/example_shop"
  },
  "title": "Example Shop",
  "description": "Premium ecommerce products from Example Shop.",
  "hostingOwner": "Shopify, Inc",
  "hostingCountry": "Canada",
  "worldSiteRank": 12345,
  "estimatedVisitorsPerDay": 1200,
  "shopifyDetected": true,
  "enrichmentStatus": "success"
}
```

### Tips for better Shopify lead lists

- Start with 10-25 leads to inspect output quality.
- Increase `maxItems` after you confirm the fields fit your workflow.
- Disable enrichment when you only need domains and MyIP.ms popularity data.
- Increase enrichment pages when contact information is more important than speed.
- Filter exported CSV rows by non-empty `emails` or social links for outreach lists.

### Integrations

Use this scraper in common sales and research workflows:

- Export CSV to a CRM such as HubSpot, Salesforce, or Pipedrive.
- Send email-rich rows to an enrichment or verification tool.
- Push social-profile rows into creator or partnership research workflows.
- Combine domains with Shopify app-install detection actors.
- Schedule recurring Apify runs and connect the dataset to Zapier or Make.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/shopify-store-leads-scraper').call({
  startUrls: [{ url: 'https://myip.ms/browse/sites/1/own/376714' }],
  maxItems: 25,
  enrichStorefronts: true
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/shopify-store-leads-scraper').call(run_input={
    'startUrls': [{'url': 'https://myip.ms/browse/sites/1/own/376714'}],
    'maxItems': 25,
    'enrichStorefronts': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~shopify-store-leads-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":25,"enrichStorefronts":true}'
```

### MCP integration

You can use this actor from Apify MCP with Claude Code or Claude Desktop.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/shopify-store-leads-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/shopify-store-leads-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-shopify-leads": {
      "url": "https://mcp.apify.com/?tools=automation-lab/shopify-store-leads-scraper"
    }
  }
}
```

Example prompts:

- "Find 25 Shopify merchant leads and summarize which have public emails."
- "Run Shopify Store Leads Scraper with enrichment disabled and export domains only."
- "Create a prospecting table from Shopify leads with Instagram profiles."

### Data quality notes

The actor extracts only public web data.
Storefront contact information may be absent, hidden behind JavaScript, or intentionally obfuscated.
Rows with `enrichmentStatus` set to `failed` still include the MyIP.ms domain and hosting fields.

### Limitations

- MyIP.ms pagination and availability can change.
- Some storefronts block automated HTTP requests.
- Phone extraction is conservative and may miss unusual formats.
- The actor does not access Shopify admin, customer accounts, private APIs, or paywalled data.

### FAQ and troubleshooting

#### Why did a lead have no email?

Many stores do not publish an email address on the pages checked by the actor.
Try increasing `maxEnrichmentPagesPerStore`, or use social/profile fields for manual qualification.

#### Why did enrichment fail for a domain?

The store may be offline, redirecting, blocking automated requests, or using a non-standard contact page.
Check the `error` field for details.

#### Why are there fewer rows than requested?

The actor stops when it exhausts parsed source rows or reaches `maxItems`.
If you use a custom source URL, confirm that the page contains a MyIP.ms sites table.

### Legality and ethical use

This actor collects public information from public websites.
You are responsible for using the data lawfully, respecting privacy rules, following anti-spam regulations, and honoring website terms.
Do not use scraped contact data for abusive, deceptive, or unlawful outreach.

### Related scrapers by automation-lab

- https://apify.com/automation-lab/shopify-scraper
- https://apify.com/automation-lab/myip-ms-scraper
- https://apify.com/automation-lab/ecommerce-leads-scraper
- https://apify.com/automation-lab/domain-email-scraper

### Changelog

#### 0.1

- Initial actor for Shopify merchant discovery and public storefront contact enrichment.

### Support

If you need a field that is visible on public storefront pages but not currently extracted, open an Apify issue with a sample domain and the expected field.

# Actor input Schema

## `startPage` (type: `integer`):

First MyIP.ms Shopify owner page number to crawl when Start URLs is empty. Page 1 contains the highest-ranked Shopify-hosted domains.

## `maxPages` (type: `integer`):

How many consecutive public MyIP.ms Shopify owner pages to read. Each page usually contains 50 domains.

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

Maximum number of merchant domains to save to the dataset.

## `startUrls` (type: `array`):

Optional MyIP.ms pages to process instead of page-number discovery, for example https://myip.ms/browse/sites/1/own/376714.

## `enrichStorefronts` (type: `boolean`):

Open each public merchant website and common contact/about pages to extract visible emails, phones, social profiles, titles, and descriptions.

## `maxEnrichmentPagesPerStore` (type: `integer`):

Maximum public storefront pages to try for each merchant. Lower values are faster and cheaper; higher values can find more contact details.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for each MyIP.ms or storefront page before skipping it.

## Actor input object example

```json
{
  "startPage": 1,
  "maxPages": 1,
  "maxItems": 10,
  "startUrls": [
    {
      "url": "https://myip.ms/browse/sites/1/own/376714"
    }
  ],
  "enrichStorefronts": true,
  "maxEnrichmentPagesPerStore": 3,
  "requestTimeoutSecs": 20
}
```

# 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 = {
    "startPage": 1,
    "maxPages": 1,
    "maxItems": 10,
    "startUrls": [
        {
            "url": "https://myip.ms/browse/sites/1/own/376714"
        }
    ],
    "enrichStorefronts": true,
    "maxEnrichmentPagesPerStore": 3,
    "requestTimeoutSecs": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/shopify-store-leads-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 = {
    "startPage": 1,
    "maxPages": 1,
    "maxItems": 10,
    "startUrls": [{ "url": "https://myip.ms/browse/sites/1/own/376714" }],
    "enrichStorefronts": True,
    "maxEnrichmentPagesPerStore": 3,
    "requestTimeoutSecs": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/shopify-store-leads-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 '{
  "startPage": 1,
  "maxPages": 1,
  "maxItems": 10,
  "startUrls": [
    {
      "url": "https://myip.ms/browse/sites/1/own/376714"
    }
  ],
  "enrichStorefronts": true,
  "maxEnrichmentPagesPerStore": 3,
  "requestTimeoutSecs": 20
}' |
apify call automation-lab/shopify-store-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Leads Scraper",
        "description": "Discover Shopify merchant domains and enrich public storefronts with emails, phones, social links, popularity signals, and metadata for ecommerce lead generation.",
        "version": "0.1",
        "x-build-id": "4tp4DdHCyZOQyLlnm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~shopify-store-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-shopify-store-leads-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~shopify-store-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-shopify-store-leads-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~shopify-store-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-shopify-store-leads-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": {
                    "startPage": {
                        "title": "First MyIP.ms page",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "First MyIP.ms Shopify owner page number to crawl when Start URLs is empty. Page 1 contains the highest-ranked Shopify-hosted domains.",
                        "default": 1
                    },
                    "maxPages": {
                        "title": "MyIP.ms pages to crawl",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many consecutive public MyIP.ms Shopify owner pages to read. Each page usually contains 50 domains.",
                        "default": 1
                    },
                    "maxItems": {
                        "title": "Maximum Shopify leads",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of merchant domains to save to the dataset.",
                        "default": 25
                    },
                    "startUrls": {
                        "title": "Custom MyIP.ms source URLs",
                        "type": "array",
                        "description": "Optional MyIP.ms pages to process instead of page-number discovery, for example https://myip.ms/browse/sites/1/own/376714.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "enrichStorefronts": {
                        "title": "Visit storefront pages",
                        "type": "boolean",
                        "description": "Open each public merchant website and common contact/about pages to extract visible emails, phones, social profiles, titles, and descriptions.",
                        "default": true
                    },
                    "maxEnrichmentPagesPerStore": {
                        "title": "Contact pages per store",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Maximum public storefront pages to try for each merchant. Lower values are faster and cheaper; higher values can find more contact details.",
                        "default": 3
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum time to wait for each MyIP.ms or storefront page before skipping it.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```