# Website Tech Stack Detector (`modular_enrichment/my-actor-1`) Actor

Detect what technology any website runs: CMS, ecommerce, analytics, pixels, chat, payments, JS frameworks, hosting/CDN, ATS, email provider (DNS). Evidence + confidence per detection. HTTP-only, fast, pay per domain. BuiltWith alternative.

- **URL**: https://apify.com/modular\_enrichment/my-actor-1.md
- **Developed by:** [Kurt Blair](https://apify.com/modular_enrichment) (community)
- **Categories:** Lead generation, Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Website Tech Stack Detector — What CMS, Analytics & Tools Any Site Uses

Find out **what technology any company website runs** — without BuiltWith's $295/month or Wappalyzer's paywall. Feed the Actor a list of domains and get one clean JSON row per company: CMS, ecommerce platform, analytics, tag managers, ad & marketing pixels, chat widgets, payment providers, JavaScript frameworks, hosting/CDN, applicant tracking system (ATS), and even the company's **email provider** from DNS — each with the exact **evidence** that triggered it and a **confidence score**.

HTTP-only and browser-free: 1–3 gentle GET requests per site plus two DNS lookups. Results stream in seconds and cost a fraction of headless-browser checkers.

### What it detects (210+ signatures, 160+ technologies)

| Category | Examples |
|---|---|
| **CMS** | WordPress, Drupal, Joomla, Ghost, Squarespace, Wix, Webflow, HubSpot CMS, Craft, TYPO3, AEM, Sitecore, Contentful, Sanity |
| **Ecommerce** | Shopify, WooCommerce, Magento, BigCommerce, PrestaShop, Salesforce Commerce Cloud, Ecwid, Snipcart |
| **Analytics** | Google Analytics, Segment, Mixpanel, Amplitude, Hotjar, Plausible, Fathom, Matomo, Heap, FullStory, Clarity, PostHog |
| **Tag managers** | Google Tag Manager, Tealium, Adobe Launch |
| **Ads / pixels** | Meta Pixel, Google Ads, LinkedIn Insight, TikTok, X, Pinterest, Reddit, Bing, Criteo, Taboola, Outbrain |
| **Marketing automation** | HubSpot, Marketo, Pardot, Klaviyo, Mailchimp, Braze, Customer.io, ActiveCampaign |
| **Chat / support** | Intercom, Drift, Zendesk, LiveChat, Crisp, Tawk.to, Freshchat, Olark, Gorgias |
| **Payments** | Stripe, PayPal, Braintree, Square, Adyen, Klarna, Affirm, Afterpay, Shop Pay |
| **JS frameworks** | Next.js, Nuxt, Gatsby, Remix, SvelteKit, Astro, Angular, React, Vue, Ember, jQuery, htmx |
| **Hosting / CDN** | Cloudflare, Netlify, Vercel, Fastly, Akamai, CloudFront, S3, GitHub Pages, WP Engine, Kinsta, Pantheon, Heroku, Fly.io, Azure |
| **Backend signals** | Nginx, Apache, IIS, PHP, Laravel, Django, Rails, ASP.NET, Express |
| **ATS (hiring)** | Greenhouse, Lever, Ashby, Workday, BambooHR, SmartRecruiters, Workable, Recruitee, iCIMS |
| **Email provider (DNS)** | Google Workspace, Microsoft 365, Zoho, Proton, Fastmail, Mimecast, Proofpoint |
| **Transactional email (DNS SPF)** | SendGrid, Mailgun, Amazon SES, Postmark, Mandrill |
| **Plus** | A/B testing (Optimizely, VWO), consent (OneTrust, Cookiebot), monitoring (Sentry, Datadog, New Relic), CAPTCHA, embeds |

Every signature is **high-precision by design**: vendor-controlled hostnames, response headers, cookie names, and unambiguous markup markers — never fuzzy keywords. When you see `"Shopify"` in your dataset, the site set a `x-shopify-stage` header, loads `cdn.shopify.com`, or declares `window.Shopify`. Precision over recall, so your enrichment data stays trustworthy.

### What can you do with technographics?

- **Sales signals / ABM tech-qualification**: sell a Shopify app? Filter 10,000 target domains down to actual Shopify stores before your SDRs touch them. Sell against Intercom? Find every account already paying for chat. Route accounts by CMS, pixel spend, or payment stack — straight into Clay, HubSpot, or your CRM.
- **Competitor & churn analysis**: track which analytics, A/B testing, and marketing tools your competitors' customers deploy — and when they switch.
- **Market research**: measure real-world market share of CMSs, checkout providers, or consent tools across any segment you define.
- **Agency prospecting**: find WordPress sites without a consent banner, stores still on Magento 1-era stacks, or sites with no analytics at all.
- **Hiring intel bonus**: the ATS detection (Greenhouse/Lever/Ashby links on careers pages) pairs directly with a job-postings scraper for a full company signal stack.

### Input

```json
{
    "domains": ["shopify.com", "hubspot.com", "vercel.com"],
    "checkCommonPaths": true,
    "dnsChecks": true,
    "maxTotalResults": 1000
}
````

Bare domains or full URLs both work; `www.` and duplicates are merged so **each domain is fetched and billed once**. Options: follow careers/jobs pages for ATS detection (on by default, max 2 extra requests), DNS email-provider checks, evidence strings on/off, minimum confidence threshold, total result cap, concurrency, proxy.

### Output (one item per domain)

```json
{
    "domain": "allbirds.com",
    "finalUrl": "https://www.allbirds.com/",
    "httpStatus": 200,
    "techCount": 9,
    "ecommercePlatform": "Shopify",
    "technologies": [
        {
            "name": "Shopify",
            "category": "ecommerce",
            "confidence": 100,
            "evidence": [
                "homepage:scriptSrc:https://cdn.shopify.com/s/files/1/1104/4168/t/303/assets/vendor.min.js",
                "homepage:header:x-shopify-stage",
                "homepage:cookie:_shopify_y"
            ]
        },
        {
            "name": "Google Workspace",
            "category": "email-provider",
            "confidence": 100,
            "evidence": ["dns:mx:aspmx.l.google.com"]
        }
    ],
    "categories": {
        "ecommerce": ["Shopify"],
        "email-provider": ["Google Workspace"]
    },
    "detectedAt": "2026-07-23T00:00:00.000Z"
}
```

Flat `cms` / `ecommercePlatform` columns plus a `categories` map make the dataset spreadsheet- and Clay-ready without post-processing; the full `technologies` array carries evidence for auditability.

### Pricing & typical cost

**Pay per result — you only pay for reachable domains.** Sites that time out or refuse to answer are logged to the `ERRORS` record and are **not billed**. Use `maxTotalResults` as a hard cost cap. A 10,000-domain enrichment run makes at most ~30,000 lightweight HTTP requests, no browser, no CAPTCHA solving — compare that with $295+/month for BuiltWith or per-lookup credit plans.

### Is this legal / compliant?

Yes, by design:

- **Company-level data only.** The Actor reports what technologies a *website* uses. It collects no personal data, no emails, no names, no profiles — nothing in scope for GDPR/CCPA personal-data rules.
- **Public information.** Every signal comes from what any browser receives when loading the public homepage (HTML, headers, cookies set on an anonymous request) and from public DNS records — the same data BuiltWith, Wappalyzer, and W3Techs have published for years.
- **Polite by construction.** Hard-capped at the homepage plus at most two same-site careers/jobs pages per domain, gentle concurrency, retries with backoff, and it **respects each page's robots meta tag** (`noindex`/`nofollow` stops link-following). No login walls, no paywalls, no circumvention.

As always, you are responsible for how you use the output in your jurisdiction.

### FAQ

**How accurate is it?** Signatures are curated for precision: a match means the vendor's own hostname, header, or cookie was present. Corroborating evidence (e.g. header + cookie + script) pushes confidence to 100. Filter with `minConfidence` if you only want multi-evidence detections.

**Why did a site return few/no technologies?** Some sites render everything client-side through a bundler, hiding third-party hostnames from static HTML (a v2 browser mode is on the roadmap); some genuinely run minimal stacks. Header/cookie/DNS signals still work on every reachable site.

**Does it work behind Cloudflare?** Yes — Cloudflare fronting is itself detected. If a site's bot protection blocks datacenter IPs, the row reports the HTTP status and header-level detections; enable residential proxy for stubborn lists.

**How fresh is the data?** Every run fetches live. Schedule the Actor (daily/weekly) and diff `technologies` downstream to catch migrations — e.g. a competitor's customer moving off Magento is a sales trigger.

**Integrations?** Dataset export as JSON/CSV/Excel, Apify API, webhooks, plus native Make, Zapier, n8n, Google Sheets, and MCP for AI agents.

# Actor input Schema

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

One entry per company website. Accepted formats: a bare domain (`shopify.com`), a full URL (`https://www.hubspot.com`), or a deep URL (`https://acme.com/pricing`). `www.` is stripped and duplicates are merged, so each domain is checked (and billed) once.

## `checkCommonPaths` (type: `boolean`):

After the homepage, follow up to 2 same-site links matching `/careers`, `/jobs`, or `/join-us` to detect the company's ATS (Greenhouse, Lever, Ashby, Workday, …) and pick up extra signals. Skipped automatically when the homepage's robots meta tag says `noindex`/`nofollow`. Turn off for the fastest, lightest runs (1 request per domain).

## `dnsChecks` (type: `boolean`):

Resolve each domain's MX and SPF (TXT) records to detect the company's email provider (Google Workspace, Microsoft 365, Zoho, …) and transactional email services (SendGrid, Mailgun, Amazon SES, Postmark, …). DNS lookups are free and fast.

## `includeEvidence` (type: `boolean`):

Each detected technology includes the exact evidence that triggered it (e.g. `homepage:scriptSrc:https://cdn.shopify.com/...`, `dns:mx:aspmx.l.google.com`). Turn off for smaller datasets.

## `minConfidence` (type: `integer`):

Only report technologies at or above this confidence. All signatures are high-precision (85–100 for a single match; corroborating evidence raises it). Default 50 keeps everything including implied technologies.

## `maxTotalResults` (type: `integer`):

Hard cap on the number of domains saved (cost control for pay-per-result billing). 0 = unlimited.

## `maxConcurrency` (type: `integer`):

Parallel requests. Each target site receives at most 3 gentle GET requests total, so even the default is polite; raise for very large domain lists.

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

Proxy settings. Apify datacenter proxy (default) is sufficient — the Actor makes 1–3 plain GET requests per site, like any link-preview bot. Residential proxy is rarely needed.

## Actor input object example

```json
{
  "domains": [
    "shopify.com",
    "hubspot.com",
    "vercel.com"
  ],
  "checkCommonPaths": true,
  "dnsChecks": true,
  "includeEvidence": true,
  "minConfidence": 50,
  "maxTotalResults": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": [
        "shopify.com",
        "hubspot.com",
        "vercel.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("modular_enrichment/my-actor-1").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": [
        "shopify.com",
        "hubspot.com",
        "vercel.com",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("modular_enrichment/my-actor-1").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": [
    "shopify.com",
    "hubspot.com",
    "vercel.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call modular_enrichment/my-actor-1 --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Tech Stack Detector",
        "description": "Detect what technology any website runs: CMS, ecommerce, analytics, pixels, chat, payments, JS frameworks, hosting/CDN, ATS, email provider (DNS). Evidence + confidence per detection. HTTP-only, fast, pay per domain. BuiltWith alternative.",
        "version": "0.0",
        "x-build-id": "OE6rXUzpmBpZRFAfm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/modular_enrichment~my-actor-1/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-modular_enrichment-my-actor-1",
                "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/modular_enrichment~my-actor-1/runs": {
            "post": {
                "operationId": "runs-sync-modular_enrichment-my-actor-1",
                "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/modular_enrichment~my-actor-1/run-sync": {
            "post": {
                "operationId": "run-sync-modular_enrichment-my-actor-1",
                "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 / websites",
                        "type": "array",
                        "description": "One entry per company website. Accepted formats: a bare domain (`shopify.com`), a full URL (`https://www.hubspot.com`), or a deep URL (`https://acme.com/pricing`). `www.` is stripped and duplicates are merged, so each domain is checked (and billed) once.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkCommonPaths": {
                        "title": "Also check careers/jobs pages",
                        "type": "boolean",
                        "description": "After the homepage, follow up to 2 same-site links matching `/careers`, `/jobs`, or `/join-us` to detect the company's ATS (Greenhouse, Lever, Ashby, Workday, …) and pick up extra signals. Skipped automatically when the homepage's robots meta tag says `noindex`/`nofollow`. Turn off for the fastest, lightest runs (1 request per domain).",
                        "default": true
                    },
                    "dnsChecks": {
                        "title": "DNS checks (email provider)",
                        "type": "boolean",
                        "description": "Resolve each domain's MX and SPF (TXT) records to detect the company's email provider (Google Workspace, Microsoft 365, Zoho, …) and transactional email services (SendGrid, Mailgun, Amazon SES, Postmark, …). DNS lookups are free and fast.",
                        "default": true
                    },
                    "includeEvidence": {
                        "title": "Include evidence strings",
                        "type": "boolean",
                        "description": "Each detected technology includes the exact evidence that triggered it (e.g. `homepage:scriptSrc:https://cdn.shopify.com/...`, `dns:mx:aspmx.l.google.com`). Turn off for smaller datasets.",
                        "default": true
                    },
                    "minConfidence": {
                        "title": "Minimum confidence (0–100)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only report technologies at or above this confidence. All signatures are high-precision (85–100 for a single match; corroborating evidence raises it). Default 50 keeps everything including implied technologies.",
                        "default": 50
                    },
                    "maxTotalResults": {
                        "title": "Max total results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the number of domains saved (cost control for pay-per-result billing). 0 = unlimited.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Parallel requests. Each target site receives at most 3 gentle GET requests total, so even the default is polite; raise for very large domain lists.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Apify datacenter proxy (default) is sufficient — the Actor makes 1–3 plain GET requests per site, like any link-preview bot. Residential proxy is rarely needed.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```