# AI Visibility Checker — ChatGPT & Perplexity Brand Audit (`mochiboo/ai-visibility-auditor`) Actor

Is your brand invisible to AI search? This AI visibility audit queries ChatGPT & Perplexity with real buyer questions, detects whether you're cited, scores 5 GEO/AEO dimensions, and returns prioritized fixes. BYOK (bring your own API key), any niche, one run — no subscription.

- **URL**: https://apify.com/mochiboo/ai-visibility-auditor.md
- **Developed by:** [mochi](https://apify.com/mochiboo) (community)
- **Categories:** AI, SEO tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.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.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

## AI Visibility Auditor — GEO & AEO Citation Audit + Fixes

**Find out if ChatGPT and Perplexity are recommending your business — and get a prioritized fix list to change that.**

Input a business name + website + niche → the actor queries ChatGPT (OpenAI) and Perplexity for the real buyer questions in your niche → detects if/where your business is cited → scores 5 dimensions → outputs a prioritized, actionable fix list.

One run = one complete audit report. No monthly subscription. Bring your own API key.

> **Replaces a $200–500/month SaaS monitor** with a $2 on-demand audit you run whenever you need it.

---

### What it does

1. **Generates buyer questions** — real questions your customers ask AI engines (niche + city-specific)
2. **Queries AI engines** — ChatGPT (GPT-4o-mini) and/or Perplexity Sonar for each question
3. **Detects citations** — checks if your business name/domain appears in AI answers
4. **Checks schema markup** — fetches your website and audits GEO-critical structured data
5. **Scores 5 dimensions** — AI citation, schema, Google Business Profile, review authority, NAP consistency
6. **Outputs prioritized fixes** — actionable recommendations, ranked by impact

---

### How to check if ChatGPT recommends your business

You can sanity-check this by hand in five minutes, then automate it:

1. **Think like your customer.** Write down 5–10 questions a buyer would actually ask an AI engine — e.g. *"best med spa in Austin"*, *"top-rated CRM for small law firms"*. Be specific to your niche and city.
2. **Ask ChatGPT and Perplexity.** Paste each question into ChatGPT and Perplexity and read the answers. Does your business get named? Linked? Recommended — or is a competitor cited instead?
3. **Check why.** AI engines lean on structured data (schema markup), your Google Business Profile, review authority, and consistent NAP (name/address/phone). Gaps here are usually why you're invisible.
4. **Score and fix.** Tally where you're cited vs missing, then prioritize the fixes with the biggest impact.

Doing this manually is slow and easy to do inconsistently. **This actor automates the whole loop**: it generates the buyer questions, queries ChatGPT & Perplexity for each, detects whether you're cited, audits your schema/GBP/reviews/NAP, scores 5 GEO/AEO dimensions, and returns a ranked fix list — one run, no subscription, bring your own API key.

---

### Why this beats the SaaS alternatives (Otterly, Profound, Peec AI)

| Feature | SaaS monitors | This actor |
|---|---|---|
| On-demand, one-time audit | ❌ subscription | ✅ |
| Actionable fix list | ❌ monitoring only | ✅ |
| Works for any niche | ❌ branded only | ✅ |
| Schema markup check | ❌ | ✅ |
| BYOK (no per-month cost) | ❌ | ✅ |
| Apify pipeline-friendly | ❌ SaaS silo | ✅ |

---

### Inputs

| Field | Required | Description |
|---|---|---|
| `businessName` | ✅ | Business to audit (e.g. "Glow Medical Spa") |
| `website` | ✅ | Business website (e.g. "glowmedicalspa.com") |
| `niche` | ✅ | Business type (e.g. "med spa", "dental clinic", "law firm") |
| `city` | ✅ | City the business is in |
| `state` | — | State / region (improves geo-targeting) |
| `services` | — | Key services/treatments (generates targeted questions) |
| `competitors` | — | Competitor names to track in AI answers |
| `openaiApiKey` | — | Your OpenAI key (BYOK — recommended; reduces per-audit cost) |
| `perplexityApiKey` | — | Your Perplexity key (BYOK — adds web-grounded citations) |
| `maxQuestions` | — | Questions to ask each engine (3–25, default 10) |
| `checkSchema` | — | Fetch + check website schema markup (default true) |
| `testMode` | — | Stub mode, no real API calls (for testing) |

---

### Output (one dataset item per audit)

```json
{
  "businessName": "Glow Medical Spa",
  "overallScore": 34,
  "tier": "Largely Invisible",
  "aiCitationScore": 10,
  "schemaScore": 25,
  "gbpScore": 40,
  "reviewScore": 30,
  "napScore": 50,
  "topPriorityFix": "Create an FAQ page answering: 'Best med spa for Botox in Austin, TX?' ...",
  "prioritized_fix_list": [ ... ],
  "dimensions": [ ... ],
  "text_report": "=== AI Visibility Auditor Report ..."
}
````

***

### LLM cost (BYOK — you control it)

- **OpenAI GPT-4o-mini:** ~$0.015–0.05 per full audit (10 questions × ~400 tokens each)
- **Perplexity Sonar:** ~$0.05–0.15 per full audit (web-grounded; higher signal)
- **Both together:** ~$0.10–0.20 typical per audit

Bring your own keys → Apify charges only the actor compute + our per-audit fee. No per-month subscription.

***

### Niches with built-in question templates

Med spa · Dental clinic · Law firm · Accounting firm · Restaurant · HVAC

Any other niche uses the generic professional-services template battery.

***

### Sample audit report (real text\_report output)

Run on a hypothetical med spa in Austin, TX with no GEO optimization in place:

```
============================================================
  AI Visibility Auditor Report
  Business: Glow Medical Spa
  Location: Austin, TX
  Generated: 2026-05-24
============================================================

  OVERALL SCORE: 28/100 — Largely Invisible

------------------------------------------------------------
  DIMENSION SCORES
------------------------------------------------------------
  AI Citation Visibility           0/100  [Invisible]
  Schema Markup                   25/100  [Weak]
  Google Business Profile         40/100  [Unverified]
  Review Authority                30/100  [Unverified]
  NAP Consistency                 50/100  [Unverified]

------------------------------------------------------------
  PRIORITIZED FIX LIST (top 10)
------------------------------------------------------------
   1. [HIGH] AI Citation Visibility
      Create an FAQ page (with FAQPage schema) answering:
      "What is the best med spa for Botox in Austin, TX?"
      — include your business name, city, services, and
      staff credentials. Most direct way to trigger AI
      citation for that query.

   2. [HIGH] AI Citation Visibility
      Create content answering: "Where can I get dermal
      fillers near Austin?" — AI engines cited a competitor
      for this query 3 times when you were not mentioned.

   3. [HIGH] Schema Markup
      Add LocalBusiness schema (name, address, phone, geo
      coordinates) — foundational for local AI citation.

   4. [HIGH] Schema Markup
      Add FAQPage schema to treatment pages — FAQs are the
      top AI citation trigger for service businesses.

   5. [MEDIUM] Schema Markup
      Add AggregateRating schema from real review sources
      (Google, Yelp) — social proof for AI engines.

   6. [MEDIUM] Google Business Profile
      Add a 250-word keyword-rich GBP description, list all
      services, add 10+ photos, verify primary category is
      "Medical Spa" not "Day Spa".

   7. [MEDIUM] Review Authority
      Implement a post-visit review request: target 50+
      Google reviews — AI engines deprioritize low-review
      practices.

   8. [MEDIUM] Review Authority
      Add service-specific review prompts — reviews
      mentioning "Botox" or "fillers" trigger AI citations
      for those exact queries.

------------------------------------------------------------
  WHAT THIS SCORE MEANS
------------------------------------------------------------
  You are being overlooked by AI search engines for most
  buyer queries. Structured fixes above will have high
  impact — the top 3 items alone cover the core gap.
============================================================
```

The full output also includes: dimension score objects, per-question citation data (which AI engine answered, whether you were mentioned, which competitors were cited instead), schema findings per type, and the complete prioritized fix list as structured JSON for downstream processing.

***

### PDPA / data privacy

Only business/organization-level data. No personal names, no personal emails. Website HTML is fetched for schema analysis only.

***

### Support & feedback

Want a niche question-template added, or hit something odd? Open an issue on the actor page.

**Found this useful? An honest review on the Apify store helps other people find it.**

***

*Keywords: AI visibility audit, GEO audit, AEO audit, ChatGPT citation checker, Perplexity visibility, AI search optimization, generative engine optimization, AI brand visibility, local business AI audit, schema markup checker, AI citation audit, GEO score, AEO score, AI recommendation audit.*

# Actor input Schema

## `businessName` (type: `string`):

The exact business name to audit (e.g. 'Glow Medical Spa').

## `website` (type: `string`):

The business website domain or URL (e.g. 'glowmedicalspa.com'). Used for schema checks and citation detection.

## `niche` (type: `string`):

The business type (e.g. 'med spa', 'dental clinic', 'law firm', 'accounting firm', 'HVAC contractor'). Used to generate niche-specific buyer questions.

## `city` (type: `string`):

City where the business operates. Used to generate geo-targeted buyer questions.

## `state` (type: `string`):

State or region (e.g. 'TX', 'California', 'Ontario'). Used for geo-targeted questions.

## `services` (type: `array`):

List of main services this business offers (e.g. \['botox', 'fillers', 'coolsculpting']). Generates service-specific audit questions.

## `competitors` (type: `array`):

Names of direct competitors you want to track in AI answers (e.g. \['Rival Spa Austin', 'Elite Aesthetics']). Used to detect competitor citation patterns.

## `openaiApiKey` (type: `string`):

Bring your own OpenAI API key to query ChatGPT/GPT-4o for buyer questions at cost (~$0.01–0.05 per audit). Leave blank to use the built-in key (higher per-audit charge applies). Your key is never stored.

## `perplexityApiKey` (type: `string`):

Bring your own Perplexity API key to query Perplexity Sonar for real-web citation detection. Leave blank to skip Perplexity queries. Your key is never stored.

## `maxQuestions` (type: `integer`):

How many buyer questions to send to AI engines. More questions = more thorough audit but higher API cost. Default 10, max 25.

## `checkSchema` (type: `boolean`):

Fetch the business website and check for GEO-critical schema markup (MedicalBusiness, FAQPage, LocalBusiness, etc.).

## `testMode` (type: `boolean`):

Run without making real API calls — uses stubbed responses. For testing the actor setup only. Results will not reflect real visibility.

## Actor input object example

```json
{
  "niche": "med spa",
  "services": [],
  "competitors": [],
  "maxQuestions": 10,
  "checkSchema": true,
  "testMode": false
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("mochiboo/ai-visibility-auditor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("mochiboo/ai-visibility-auditor").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 '{}' |
apify call mochiboo/ai-visibility-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mochiboo/ai-visibility-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Visibility Checker — ChatGPT & Perplexity Brand Audit",
        "description": "Is your brand invisible to AI search? This AI visibility audit queries ChatGPT & Perplexity with real buyer questions, detects whether you're cited, scores 5 GEO/AEO dimensions, and returns prioritized fixes. BYOK (bring your own API key), any niche, one run — no subscription.",
        "version": "1.0",
        "x-build-id": "d3Eo5bqqRjs0T7Jis"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mochiboo~ai-visibility-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mochiboo-ai-visibility-auditor",
                "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/mochiboo~ai-visibility-auditor/runs": {
            "post": {
                "operationId": "runs-sync-mochiboo-ai-visibility-auditor",
                "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/mochiboo~ai-visibility-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-mochiboo-ai-visibility-auditor",
                "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": [
                    "businessName",
                    "website",
                    "niche",
                    "city"
                ],
                "properties": {
                    "businessName": {
                        "title": "Business Name",
                        "type": "string",
                        "description": "The exact business name to audit (e.g. 'Glow Medical Spa')."
                    },
                    "website": {
                        "title": "Business Website",
                        "type": "string",
                        "description": "The business website domain or URL (e.g. 'glowmedicalspa.com'). Used for schema checks and citation detection."
                    },
                    "niche": {
                        "title": "Business Niche / Category",
                        "type": "string",
                        "description": "The business type (e.g. 'med spa', 'dental clinic', 'law firm', 'accounting firm', 'HVAC contractor'). Used to generate niche-specific buyer questions.",
                        "default": "med spa"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City where the business operates. Used to generate geo-targeted buyer questions."
                    },
                    "state": {
                        "title": "State / Region",
                        "type": "string",
                        "description": "State or region (e.g. 'TX', 'California', 'Ontario'). Used for geo-targeted questions."
                    },
                    "services": {
                        "title": "Key Services / Treatments",
                        "type": "array",
                        "description": "List of main services this business offers (e.g. ['botox', 'fillers', 'coolsculpting']). Generates service-specific audit questions.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "competitors": {
                        "title": "Known Competitors (optional)",
                        "type": "array",
                        "description": "Names of direct competitors you want to track in AI answers (e.g. ['Rival Spa Austin', 'Elite Aesthetics']). Used to detect competitor citation patterns.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "openaiApiKey": {
                        "title": "Your OpenAI API Key (optional — recommended)",
                        "type": "string",
                        "description": "Bring your own OpenAI API key to query ChatGPT/GPT-4o for buyer questions at cost (~$0.01–0.05 per audit). Leave blank to use the built-in key (higher per-audit charge applies). Your key is never stored."
                    },
                    "perplexityApiKey": {
                        "title": "Your Perplexity API Key (optional — recommended)",
                        "type": "string",
                        "description": "Bring your own Perplexity API key to query Perplexity Sonar for real-web citation detection. Leave blank to skip Perplexity queries. Your key is never stored."
                    },
                    "maxQuestions": {
                        "title": "Max Buyer Questions to Query",
                        "minimum": 3,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many buyer questions to send to AI engines. More questions = more thorough audit but higher API cost. Default 10, max 25.",
                        "default": 10
                    },
                    "checkSchema": {
                        "title": "Check Website Schema Markup",
                        "type": "boolean",
                        "description": "Fetch the business website and check for GEO-critical schema markup (MedicalBusiness, FAQPage, LocalBusiness, etc.).",
                        "default": true
                    },
                    "testMode": {
                        "title": "Test Mode (no live API calls)",
                        "type": "boolean",
                        "description": "Run without making real API calls — uses stubbed responses. For testing the actor setup only. Results will not reflect real visibility.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
