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

Turn a domain list into qualified Shopify B2B leads. Detects Shopify stores via /products.json, response headers, and HTML markers — enriches with product count, contact email, social links, and currency. Works on stores that block the products endpoint.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Shopify Store Leads Scraper

**$2.50 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

Give us a list of domains. We'll tell you which ones are Shopify stores — and for each one we enrich product count, sample product titles, contact email, social links, and detected currency. Whether the store serves `/products.json` cleanly or blocks it entirely, we find a way through.

</div>

---

### 🎯 What this scrapes

Shopify powers over 4 million stores worldwide. This Actor takes a list of website domains and runs multi-signal detection across each one: it tries `/products.json`, reads HTTP headers (`x-shopify-stage`, `x-sorting-hat-shopid`, `powered-by`), and scans the homepage HTML for `cdn.shopify.com`, `Shopify.theme`, and `*.myshopify.com` references. Whichever signal fires first wins. Confirmed Shopify stores are then enriched with product count, a sample of product titles, the `*.myshopify.com` subdomain, any contact email found on the homepage or `/contact` page, social profile links, and the storefront currency.

Run it once to qualify a prospect list, or schedule it weekly to monitor an entire vertical.

### 🔥 What we handle for you

- 🛡️ **Multi-signal detection** — three independent detection layers so stores that block `/products.json` (like Gymshark) are still correctly identified via headers and HTML markers.
- 🌐 **Residential proxy rotation** via Apify Proxy — fresh session and exit IP on every request so your detection run doesn't get flagged as a crawler.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` — up to 5 attempts per domain, `Retry-After` honoured.
- 🧱 **Rate-limit-aware pacing** — when a CDN or WAF pushes back, we slow down and rotate before retrying, not after failing.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, JSON / CSV / Excel export from the Apify Console.
- 💰 **Pay-Per-Event pricing** — you pay only for confirmed results that hit your dataset. Zero rows, zero charge (beyond the small start event).

### 💡 Use cases

- **Shopify app vendor prospecting** — feed a domain list from a niche directory, get back every Shopify store with email and product count, ready to import into your CRM.
- **DTC agency outreach** — qualify inbound leads: "does this prospect actually run Shopify?" answered programmatically, no manual checks.
- **Competitive intelligence** — track which new entrants in a product category have spun up Shopify stores over the last 30 days.
- **Platform migration research** — identify the Shopify footprint in a specific industry vertical before pitching a replatforming project.
- **Market-sizing for app developers** — count confirmed Shopify stores in a niche to validate an app idea before building.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Paste your domain list into the **Domains to check** field — one domain per line, bare domains or full URLs both work.
3. Adjust **Max products to sample**, **Only Shopify stores**, and the proxy settings as needed.
4. Click **Start**. Rows stream into the dataset as each domain is resolved.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch via the Apify API.

For no-code workflows: install the [Apify node for n8n](https://n8n.io/integrations/apify/) or the [Apify module for Make](https://www.make.com/en/integrations/apify), connect your token, and point it at `DevilScrapes/shopify-store-leads-scraper`.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `domains` | `array` | **yes** | `["allbirds.com", "gymshark.com"]` | Domains or URLs to probe. Scheme and path are stripped automatically. |
| `includeProducts` | `boolean` | no | `true` | Fetch product count + sample titles from `/products.json` or sitemap. |
| `maxProductsSample` | `integer` | no | `10` | Max product titles per domain (1–250). |
| `onlyShopify` | `boolean` | no | `true` | Drop non-Shopify domains from the dataset. Set `false` for a full audit. |
| `maxResults` | `integer` | no | `50` | Hard cap on rows emitted. `0` = unlimited. |
| `proxyConfiguration` | `object` | no | Apify residential proxy | Proxy routing. Residential recommended to avoid datacenter blocks. |

#### Example input

```json
{
  "domains": ["allbirds.com", "gymshark.com", "kylie.com"],
  "includeProducts": true,
  "maxProductsSample": 10,
  "onlyShopify": true,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### 📤 Output

One dataset row per probed domain (or per confirmed Shopify store when `onlyShopify=true`).

| Field | Type | Notes |
|---|---|---|
| `domain` | `string` | Normalised domain that was probed. |
| `is_shopify` | `boolean` | `true` when any detection signal confirmed Shopify. |
| `detection_method` | `string \| null` | Which signal fired: `products_json`, `headers`, `html_markers`, or `none`. |
| `myshopify_domain` | `string \| null` | `*.myshopify.com` subdomain when discoverable. |
| `product_count` | `integer \| null` | Total products reported by `/products.json`. Null when endpoint blocked. |
| `sample_product_titles` | `array[string]` | Up to `maxProductsSample` product titles. |
| `currency` | `string \| null` | ISO-4217 currency detected on the storefront (e.g. `USD`, `GBP`). |
| `email` | `string \| null` | Contact email found via `mailto:` links on the homepage or `/contact`. |
| `social_links` | `array[string]` | Social profile URLs found on the homepage. |
| `homepage_title` | `string \| null` | `<title>` text of the homepage. |
| `scraped_at` | `string` | ISO-8601 UTC timestamp. |

#### Example output

```json
{
  "domain": "allbirds.com",
  "is_shopify": true,
  "detection_method": "products_json",
  "myshopify_domain": "allbirds.myshopify.com",
  "product_count": 87,
  "sample_product_titles": [
    "Men's Tree Runners",
    "Women's Wool Runners",
    "Tree Dasher 2"
  ],
  "currency": "USD",
  "email": null,
  "social_links": [
    "https://www.instagram.com/allbirds/",
    "https://twitter.com/allbirds",
    "https://www.facebook.com/allbirds"
  ],
  "homepage_title": "Allbirds | Sustainable, Comfortable Shoes Made With Natural Materials",
  "scraped_at": "2026-06-07T10:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result-row` | $0.0025 | Per dataset row written |

Example: 1 000 confirmed Shopify leads at the rates above ≈ **$2.50**. No subscription, no minimum, no card to start — Apify gives every new account $5 free credit, good for 2 000 enriched leads before you owe anything.

### 🚧 Limitations

- **Some stores block `/products.json`**: stores like Gymshark return 403. We fall back to header and HTML-marker detection, which confirms Shopify but can't retrieve product lists — `product_count` and `sample_product_titles` will be null for those.
- **Email is best-effort**: many Shopify stores hide contact email behind forms or Zendesk widgets. We surface `mailto:` links only; JavaScript-rendered contact forms are out of scope for the HTTP-tier implementation.
- **Social links are homepage-scraped**: some brands link social accounts only in the footer of inner pages. If they're not on the homepage, they won't appear.
- **Rate limiting on large lists**: running thousands of domains in a single Actor run is possible but slow. Batch in groups of 500–1 000 for predictable run times. Use `maxResults` to cap during testing.
- **Shopify Markets / headless**: some enterprise Shopify deployments use custom domains + headless frontends that mask Shopify signals entirely. Detection rates on headless stores are lower.

### ❓ FAQ

**Does this work on stores that block /products.json?**

Yes. The Actor tries `/products.json` first, but it doesn't stop there. It also reads HTTP response headers (`x-shopify-stage`, `x-sorting-hat-shopid`) and scans the homepage HTML for Shopify CDN references and theme globals. A store that 403s `/products.json` will still be detected if any other signal is present — we just won't be able to populate `product_count` for it.

**What domains should I feed it?**

Any list of website domains works — e-commerce databases, trade-show exhibitor lists, Google Shopping scrape results, brand registries, or your own prospect pipeline. The Actor normalises URLs to bare domains automatically.

**How accurate is the detection?**

The three-signal approach catches the vast majority of Shopify stores. False positives are rare (we require at least one confirmed Shopify marker, not just heuristics). False negatives occur mainly on headless Shopify deployments that strip all Shopify headers and serve no Shopify CDN assets from the homepage.

**Can I get more than 10 product titles per store?**

Yes — raise `maxProductsSample` up to 250. Keep in mind that `/products.json?limit=250` is a single larger request, which may tip rate-limit thresholds on stores that monitor request size.

**Can I run this on a schedule?**

Yes — wire it to an [Apify Schedule](https://docs.apify.com/platform/schedules) and pass a static domain list. Useful for monitoring when a specific set of competitor domains migrates onto Shopify.

**I need the full product catalogue, not just a sample — can you do that?**

That's a different use case (deep product scraping) and outside the scope of this lead-gen Actor. If you need full catalogue extraction, contact us via the Issues tab.

### 💬 Your feedback

Spotted a false negative, hit a detection miss, or need an extra enrichment field? Open an issue on the Actor's **Issues** tab in Apify Console — we ship fixes weekly and every report gets read.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `domains` (type: `array`):

List of website domains or URLs to probe. Include the domain only (e.g. <code>allbirds.com</code>) or a full URL — the Actor normalises both. At least one domain is required.

## `includeProducts` (type: `boolean`):

Fetch a sample of product titles from <code>/products.json</code> or the sitemap when the endpoint responds. Adds <code>product\_count</code> and <code>sample\_product\_titles</code> to every row.

## `maxProductsSample` (type: `integer`):

Upper bound on product titles fetched per domain. Caps the <code>/products.json?limit=N</code> request and the sitemap scan.

## `onlyShopify` (type: `boolean`):

When <code>true</code>, non-Shopify domains are silently dropped from the dataset. Set to <code>false</code> to get a full audit of every domain checked.

## `maxResults` (type: `integer`):

Hard cap on dataset rows emitted. Useful when testing or on a budget. Set to <code>0</code> for unlimited.

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

Apify Proxy configuration. Residential proxies are recommended — many Shopify stores block repeated requests from datacenter IP ranges.

## Actor input object example

```json
{
  "domains": [
    "allbirds.com",
    "gymshark.com"
  ],
  "includeProducts": true,
  "maxProductsSample": 10,
  "onlyShopify": true,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

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

No description

## `datasetView` (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 = {
    "domains": [
        "allbirds.com",
        "gymshark.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/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 = {
    "domains": [
        "allbirds.com",
        "gymshark.com",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/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 '{
  "domains": [
    "allbirds.com",
    "gymshark.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call devilscrapes/shopify-store-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shopify Store Leads Scraper",
        "description": "Turn a domain list into qualified Shopify B2B leads. Detects Shopify stores via /products.json, response headers, and HTML markers — enriches with product count, contact email, social links, and currency. Works on stores that block the products endpoint.",
        "version": "0.1",
        "x-build-id": "bUN5f7Fjg9fDynIio"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~shopify-store-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-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/devilscrapes~shopify-store-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-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/devilscrapes~shopify-store-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-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",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains to check",
                        "minItems": 1,
                        "type": "array",
                        "description": "List of website domains or URLs to probe. Include the domain only (e.g. <code>allbirds.com</code>) or a full URL — the Actor normalises both. At least one domain is required.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeProducts": {
                        "title": "Include product sample",
                        "type": "boolean",
                        "description": "Fetch a sample of product titles from <code>/products.json</code> or the sitemap when the endpoint responds. Adds <code>product_count</code> and <code>sample_product_titles</code> to every row.",
                        "default": true
                    },
                    "maxProductsSample": {
                        "title": "Max products to sample",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Upper bound on product titles fetched per domain. Caps the <code>/products.json?limit=N</code> request and the sitemap scan.",
                        "default": 10
                    },
                    "onlyShopify": {
                        "title": "Only Shopify stores in output",
                        "type": "boolean",
                        "description": "When <code>true</code>, non-Shopify domains are silently dropped from the dataset. Set to <code>false</code> to get a full audit of every domain checked.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on dataset rows emitted. Useful when testing or on a budget. Set to <code>0</code> for unlimited.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Residential proxies are recommended — many Shopify stores block repeated requests from datacenter IP ranges."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
