# Wappalyzer Technology Lookup (`automation-lab/wappalyzer-technology-lookup`) Actor

🔎 Detect CMS, ecommerce, analytics, CDN, hosting, frameworks, headers, scripts, and evidence from public website domains and URLs.

- **URL**: https://apify.com/automation-lab/wappalyzer-technology-lookup.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Wappalyzer Technology Lookup

Detect the public technology stack behind websites from a list of domains or URLs. This actor is built for enrichment workflows where you need normalized CMS, ecommerce, analytics, CDN, hosting, JavaScript framework, and server evidence without running a browser.

### What does Wappalyzer Technology Lookup do?

Wappalyzer Technology Lookup fetches public website pages, reads response headers and HTML, extracts script/style/meta signals, and returns technology matches with confidence scores and evidence. It is a lightweight alternative to a browser-based site audit when you need fast lead-list enrichment.

### Who is it for?

- 🧑‍💼 Sales teams enriching company/domain lists before outreach.
- 📈 Growth teams finding Shopify, WordPress, Webflow, or analytics users.
- 🧰 Agencies qualifying prospects by CMS, ecommerce platform, CDN, or hosting.
- 🔎 SEO and competitive-intelligence teams comparing public technology stacks.
- 🧪 Data teams adding technology fields to CRM, warehouse, or Clay-style workflows.

### Why use this actor?

- HTTP-first: fast and inexpensive for large lists.
- One row per website: easy to export to CSV, Sheets, or a CRM.
- Evidence included: audit why a technology was detected.
- Flat and nested fields: use `technologyNames` for spreadsheets and `technologies` for richer apps.
- Optional raw signals: keep datasets small by default, expand when needed.

### What technologies can it detect?

The initial signature map covers common public signals including WordPress, WooCommerce, Shopify, Wix, Squarespace, Webflow, Drupal, Joomla, React, Next.js, Nuxt.js, Vue.js, Angular, Google Analytics, Google Tag Manager, Meta Pixel, Cloudflare, Akamai, Fastly, Nginx, Apache, Vercel, Netlify, Bootstrap, and jQuery.

### Data table

| Field | Description |
| --- | --- |
| `input` | Normalized input URL/domain. |
| `url` | Starting URL. |
| `finalUrl` | URL after redirects. |
| `domain` | Hostname without leading `www`. |
| `statusCode` | First page HTTP status. |
| `title` | Page title. |
| `metaGenerator` | CMS generator meta tag if present. |
| `technologies` | Technology objects with name, category, confidence, and evidence. |
| `technologyNames` | Flat list of technology names. |
| `categories` | Flat list of detected categories. |
| `confidence` | Average technology confidence. |
| `pageCount` | Number of pages inspected. |
| `pages` | Per-page signal summary. |
| `error` | Fetch error if the site could not be reached. |
| `detectedAt` | ISO timestamp. |

### How much does it cost to detect website technology stacks?

The actor uses pay-per-event pricing: a **$0.005 run-start fee** plus a per-website result charge. Because it runs HTTP requests instead of browsers by default, it is designed for affordable bulk enrichment.

| Apify plan tier | Per website result | Example calculation for 1,000 websites |
| --- | ---: | --- |
| FREE | $0.0002405 | 0.005 start + 1,000 × 0.0002405 = 0.2455 USD |
| BRONZE | $0.00020913 | 0.005 start + 1,000 × 0.00020913 = 0.21413 USD |
| SILVER | $0.00016312 | 0.005 start + 1,000 × 0.00016312 = 0.16812 USD |
| GOLD | $0.00012548 | 0.005 start + 1,000 × 0.00012548 = 0.13048 USD |
| PLATINUM | $0.000083653 | 0.005 start + 1,000 × 0.000083653 = 0.088653 USD |
| DIAMOND | $0.000058557 | 0.005 start + 1,000 × 0.000058557 = 0.063557 USD |

Free-plan estimate: checking 100 websites costs about **0.02905 USD** (`0.005 + 100 × 0.0002405`). Checking 10,000 websites on BRONZE costs about **2.0963 USD** (`0.005 + 10,000 × 0.00020913`). Exact live pricing is shown on the Apify actor page and may vary by your Apify plan tier.

### How to use Wappalyzer Technology Lookup

1. Open the actor on Apify.
2. Paste website URLs into **Website URLs** or bare domains into **Domains**.
3. Keep **Max pages per domain** at `1` for fast lead enrichment.
4. Increase it to `2-5` if you need more same-domain evidence.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or via API.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.shopify.com" },
    { "url": "https://wordpress.org" }
  ],
  "domains": ["example.com"],
  "maxPagesPerDomain": 1,
  "requestTimeoutSecs": 20,
  "includeRawSignals": false
}
````

### Output example

```json
{
  "domain": "shopify.com",
  "statusCode": 200,
  "technologyNames": ["Cloudflare", "Google Analytics", "React", "Shopify"],
  "categories": ["Analytics", "CDN", "Ecommerce", "JavaScript framework"],
  "confidence": 90,
  "technologies": [
    {
      "name": "Shopify",
      "category": "Ecommerce",
      "confidence": 96,
      "evidence": ["Shopify asset or global"]
    }
  ]
}
```

### Tips for best results

- Use canonical homepage URLs when you have them.
- Bare domains are fine; the actor adds `https://` automatically.
- Keep `includeRawSignals` off for normal CRM exports.
- Enable `includeRawSignals` when you need audit evidence for scripts and headers.
- Use small page depth for large lists; higher depth costs more and takes longer.

### Integrations

Use this actor in workflows such as:

- Enrich a CSV of prospect domains before importing into HubSpot or Salesforce.
- Add technology tags to a Clay, Airtable, or Google Sheets pipeline.
- Monitor a list of competitors for CMS or ecommerce changes.
- Feed technology names into lead scoring or segmentation rules.
- Combine with contact-finding actors from `https://apify.com/automation-lab/` for account research.

### 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/wappalyzer-technology-lookup').call({
  domains: ['shopify.com', 'wordpress.org'],
  maxPagesPerDomain: 1
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/wappalyzer-technology-lookup').call(run_input={
    'domains': ['shopify.com', 'wordpress.org'],
    'maxPagesPerDomain': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage: cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~wappalyzer-technology-lookup/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"domains":["shopify.com","wordpress.org"],"maxPagesPerDomain":1}'
```

### MCP usage

Use the Apify MCP server with Claude Desktop or Claude Code:

```bash
claude mcp add apify-wappalyzer-technology-lookup https://mcp.apify.com/?tools=automation-lab/wappalyzer-technology-lookup
```

For Claude Desktop, add an MCP server configuration like this:

```json
{
  "mcpServers": {
    "apify-wappalyzer-technology-lookup": {
      "url": "https://mcp.apify.com/?tools=automation-lab/wappalyzer-technology-lookup"
    }
  }
}
```

Example prompts:

- "Detect technologies for these 50 prospect domains and group them by ecommerce platform."
- "Find which of these competitor sites use Shopify, WordPress, or Webflow."
- "Return domains with Google Tag Manager and Cloudflare from this input list."

### Reliability notes

This actor detects public signals visible in headers and HTML. Some technologies are only visible after user interactions, login, or browser execution. For those sites, results may be partial. The actor reports reachable pages and errors so you can identify failed domains.

### Proxy guidance

Most website technology lookups do not need proxies. Leave proxy disabled for lower cost. If a specific target list blocks requests, enable Apify Proxy or provide your own proxy URLs.

### Legality and ethics

The actor uses public webpages supplied by the user and does not log in, bypass private areas, or collect personal data by design. Always follow target website terms, applicable laws, and your internal data policies.

### FAQ

#### Is this the official Wappalyzer product?

No. It is an Apify actor that performs Wappalyzer-style public technology detection using local signatures and evidence fields.

#### Why is a technology missing?

The website may hide it behind JavaScript, load it only after consent, or use custom asset names. Increase page depth or enable raw signals for audit trails.

#### Why did a domain return an error?

The domain may not resolve, may block automated HTTP clients, or may require a browser. Check the `error` field and retry with a proxy if appropriate.

#### Can I enrich thousands of domains?

Yes. Keep page depth at `1`, disable raw signals, and use batched runs for predictable cost and runtime.

### Related scrapers

Use these specific automation-lab actors with Wappalyzer Technology Lookup:

- [Tech Stack Detector](https://apify.com/automation-lab/tech-stack-detector) — broader technology stack detection workflows.
- [Shopify Store Analyzer](https://apify.com/automation-lab/shopify-store-analyzer) — inspect Shopify stores after this actor flags Shopify technology.
- [Website Change Monitor](https://apify.com/automation-lab/website-change-monitor) — monitor domains where technology changes matter.
- [Broken Link Checker](https://apify.com/automation-lab/broken-link-checker) — combine technology enrichment with website QA checks.
- [Email Finder](https://apify.com/automation-lab/email-finder) — find outreach emails for domains enriched by technology stack.

### Changelog

- 0.1 — Initial HTTP-first technology lookup with normalized evidence output.

### Support

If a site category is important for your workflow and is not detected yet, open an Apify issue with example URLs and the expected technology. Include dataset rows so the signature can be improved.

# Actor input Schema

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

Public website URLs to inspect. You can also use the Domains field below for bare domains.

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

Optional bare domains, one per item. The actor automatically adds https:// when a scheme is missing.

## `maxPagesPerDomain` (type: `integer`):

Inspect the homepage plus a few same-domain links for more signals. Keep low for fast enrichment jobs.

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

Maximum time to wait for each page request.

## `includeRawSignals` (type: `boolean`):

Include more response headers, script URLs, and stylesheet URLs for audit trails. Disable for smaller datasets.

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

Optional Apify proxy settings. Most public websites work without a proxy; enable only when your target domains block datacenter traffic.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.shopify.com"
    },
    {
      "url": "https://wordpress.org"
    }
  ],
  "domains": [
    "example.com"
  ],
  "maxPagesPerDomain": 1,
  "requestTimeoutSecs": 20,
  "includeRawSignals": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.shopify.com"
        },
        {
            "url": "https://wordpress.org"
        }
    ],
    "domains": [
        "example.com"
    ],
    "maxPagesPerDomain": 1,
    "requestTimeoutSecs": 20,
    "includeRawSignals": false,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/wappalyzer-technology-lookup").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 = {
    "startUrls": [
        { "url": "https://www.shopify.com" },
        { "url": "https://wordpress.org" },
    ],
    "domains": ["example.com"],
    "maxPagesPerDomain": 1,
    "requestTimeoutSecs": 20,
    "includeRawSignals": False,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/wappalyzer-technology-lookup").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 '{
  "startUrls": [
    {
      "url": "https://www.shopify.com"
    },
    {
      "url": "https://wordpress.org"
    }
  ],
  "domains": [
    "example.com"
  ],
  "maxPagesPerDomain": 1,
  "requestTimeoutSecs": 20,
  "includeRawSignals": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/wappalyzer-technology-lookup --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wappalyzer Technology Lookup",
        "description": "🔎 Detect CMS, ecommerce, analytics, CDN, hosting, frameworks, headers, scripts, and evidence from public website domains and URLs.",
        "version": "0.1",
        "x-build-id": "ocJXlhDPOOw7q9f9e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~wappalyzer-technology-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-wappalyzer-technology-lookup",
                "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~wappalyzer-technology-lookup/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-wappalyzer-technology-lookup",
                "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~wappalyzer-technology-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-wappalyzer-technology-lookup",
                "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": {
                    "startUrls": {
                        "title": "Website URLs",
                        "type": "array",
                        "description": "Public website URLs to inspect. You can also use the Domains field below for bare domains.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "Optional bare domains, one per item. The actor automatically adds https:// when a scheme is missing.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Max pages per domain",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Inspect the homepage plus a few same-domain links for more signals. Keep low for fast enrichment jobs.",
                        "default": 1
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum time to wait for each page request.",
                        "default": 20
                    },
                    "includeRawSignals": {
                        "title": "Include raw signals",
                        "type": "boolean",
                        "description": "Include more response headers, script URLs, and stylesheet URLs for audit trails. Disable for smaller datasets.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy settings. Most public websites work without a proxy; enable only when your target domains block datacenter traffic."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```