# Answer The Public (`deadlyaccurate/answer-the-public`) Actor

Extract comprehensive keyword research data from AnswerThePublic.com for any keyword. Get search insights from multiple sources including Google, Bing, YouTube, TikTok, Instagram, Amazon, and ChatGPT.

- **URL**: https://apify.com/deadlyaccurate/answer-the-public.md
- **Developed by:** [Doug Silkstone](https://apify.com/deadlyaccurate) (community)
- **Categories:** SEO tools, Automation, AI
- **Stats:** 129 total users, 14 monthly users, 0.0% runs succeeded, 6 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Answer the Public Scraper

Extract comprehensive keyword research data from AnswerThePublic.com]for any keyword. Get search insights from multiple sources including Google, Bing, YouTube, TikTok, Instagram, Amazon, and ChatGPT.

Want to learn more? Check out the comprehensive docs site here: https://withseismic.com/apify-actors/answer-the-public

### What data can you extract?

This actor retrieves comprehensive keyword research data from Answer the Public across multiple platforms:

#### Data Sources
- **Search Engines**: Google Web, Bing
- **Social Media**: YouTube, TikTok, Instagram
- **E-commerce**: Amazon
- **AI Platforms**: ChatGPT

#### Metrics & Insights
- Related search queries and questions
- Search volume estimates
- Cost per click (CPC) data
- Trending topics and comparisons
- Question-based searches (who, what, when, where, why, how)
- Preposition-based searches (for, with, to, near, etc.)

Perfect for SEO research, content planning, market research, and competitive analysis.

### Why use this actor?

Answer the Public limits free accounts to **3 searches per day**. This actor provides programmatic access to the same free-tier data without daily search limits, making it ideal for:

- Bulk keyword research across hundreds or thousands of terms
- Automated SEO workflows and content pipelines
- Regular competitive monitoring and trend analysis
- Building keyword databases without manual daily searches

**Note**: This actor returns the same data available to free Answer the Public accounts. For premium features like alphabetical lists and extended data, you would need an Answer the Public subscription.

### Features

- Extract data for multiple keywords in a single run
- Support for different languages and regions
- Comprehensive data from 7+ different sources
- Automatic handling of search completion
- Clean, structured JSON output
- No daily search limits

### Input

The actor accepts the following input parameters:

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `keywords` | Array | Yes | - | List of keywords to research |
| `language` | String | No | `"en"` | Language code (e.g., 'en', 'es', 'fr') |
| `region` | String | No | `"us"` | Region code (e.g., 'us', 'uk', 'ca') |
| `maxPollAttempts` | Number | No | `60` | Maximum attempts to wait for results |
| `pollInterval` | Number | No | `5000` | Time between checks in milliseconds |

#### Input Example

```json
{
  "keywords": ["james bond", "coffee beans", "yoga mat"],
  "language": "en",
  "region": "us"
}
````

### Output

The actor stores results in the default dataset. Each item contains:

| Field | Type | Description |
|-------|------|-------------|
| `keyword` | String | The searched keyword |
| `language` | String | Language used for search |
| `region` | String | Region used for search |
| `parentSearchId` | String | Unique search identifier |
| `data` | Object | Complete search results organized by category |
| `completedAt` | String | ISO timestamp of completion |

#### Output Structure

Results are organized into four main categories:

##### 1. Search Engines

- **Google Web** (`gweb`)
- **Bing** (`bing`)

##### 2. Social Media

- **YouTube** (`youtube`)
- **TikTok** (`tiktok`)
- **Instagram** (`instagram`)

##### 3. Shopping

- **Amazon** (`amazon`)

##### 4. AI

- **ChatGPT** (`chatgpt`)

Each source provides:

- **Completion status** - Whether the search has finished
- **Search results data** - Array of related queries, questions, and topics
- **Result counts** - Total number of results found
- **Search volume metrics** - Estimated monthly search volume
- **Cost per click estimates** - Average CPC for paid advertising
- **Pagination info** - Page number, total pages, results per page

#### What's Inside the Results?

Each platform returns different types of data:

**Search Engines (Google, Bing)**

- Question-based queries (Who, What, When, Where, Why, How)
- Preposition-based queries (for, with, to, near, etc.)
- Comparison queries (vs, versus, or, and)
- Related search terms
- Alphabetical query variations

**Social Media (YouTube, TikTok, Instagram)**

- Trending video topics
- Popular hashtags
- Content creator suggestions
- Related channels/accounts

**E-commerce (Amazon)**

- Product search queries
- Shopping-related questions
- Product comparison terms

**AI (ChatGPT)**

- Common prompts and questions
- Related conversation topics

#### Output Example

```json
{
  "keyword": "james bond",
  "language": "en",
  "region": "us",
  "parentSearchId": "abc123",
  "completedAt": "2025-11-17T00:45:30.000Z",
  "data": {
    "search_engine": {
      "gweb": {
        "completed": true,
        "status": "completed",
        "results": {
          "data": [...],
          "page_info": {...}
        },
        "total_results_count": 150
      },
      "bing": {
        "completed": true,
        "status": "completed",
        "results": {
          "data": [...],
          "page_info": {...}
        },
        "total_results_count": 120
      }
    },
    "social_media": {
      "youtube": {
        "completed": true,
        "status": "completed",
        "results": {
          "data": [...],
          "page_info": {...}
        },
        "total_results_count": 85
      },
      "tiktok": {
        "completed": true,
        "status": "completed",
        "results": {
          "data": [...],
          "page_info": {...}
        },
        "total_results_count": 45
      },
      "instagram": {
        "completed": true,
        "status": "completed",
        "results": {
          "data": {
            "hashtags": [],
            "people": []
          },
          "page_info": {...}
        },
        "total_results_count": 0
      }
    },
    "shopping": {
      "amazon": {
        "completed": true,
        "status": "completed",
        "results": {
          "data": [...],
          "page_info": {...}
        },
        "total_results_count": 95
      }
    },
    "ai": {
      "chatgpt": {
        "completed": true,
        "status": "completed",
        "results": {
          "data": [...],
          "page_info": {...}
        },
        "total_results_count": 60
      }
    },
    "max_search_volume": 201000,
    "max_cost_per_click": 34.735
  }
}
```

### How to Use

#### Using the Apify Console

1. Navigate to the [actor's page](https://apify.com/YOUR_USERNAME/answer-the-public-scraper)
2. Click "Try for free"
3. Enter your keywords and configuration
4. Click "Start" and wait for results
5. Download data as JSON, CSV, or Excel

#### Using the Apify API (JavaScript/Node.js)

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const input = {
    keywords: ["sustainable fashion", "eco friendly products", "vegan leather"],
    language: "en",
    region: "us"
};

// Start the actor and wait for it to finish
const run = await client.actor("YOUR_ACTOR_ID").call(input);

// Fetch results from the dataset
const { items } = await client.dataset(run.defaultDatasetId).listItems();

// Process the results
items.forEach((item) => {
    console.log(`\n=== ${item.keyword} ===`);
    console.log(`Search Volume: ${item.data.max_search_volume}`);
    console.log(`Max CPC: $${item.data.max_cost_per_click}`);

    // Access Google search data
    const googleData = item.data.search_engine.gweb;
    console.log(`Google results: ${googleData.total_results_count}`);

    // Access YouTube data
    const youtubeData = item.data.social_media.youtube;
    console.log(`YouTube results: ${youtubeData.total_results_count}`);
});
```

#### Using Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

## Prepare input
run_input = {
    "keywords": ["sustainable fashion", "eco friendly products"],
    "language": "en",
    "region": "us"
}

## Run the actor and wait for it to finish
run = client.actor("YOUR_ACTOR_ID").call(run_input=run_input)

## Fetch results
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"Keyword: {item['keyword']}")
    print(f"Search Volume: {item['data']['max_search_volume']}")
    print(f"CPC: ${item['data']['max_cost_per_click']}")
```

#### Using Apify CLI

```bash
## Run the actor
apify call YOUR_ACTOR_ID --input '{
  "keywords": ["digital marketing", "seo tools"],
  "language": "en",
  "region": "us"
}'

## Download results as JSON
apify dataset download
```

#### Using cURL (REST API)

```bash
curl -X POST https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -d '{
    "keywords": ["keyword research"],
    "language": "en",
    "region": "us"
  }'
```

#### Working with the Data

Once you have the results, you can access specific data points:

```javascript
// Access search engine data
const googleResults = item.data.search_engine.gweb.results.data;
const bingResults = item.data.search_engine.bing.results.data;

// Access social media insights
const youtubeResults = item.data.social_media.youtube.results.data;
const tiktokResults = item.data.social_media.tiktok.results.data;
const instagramHashtags = item.data.social_media.instagram.results.data.hashtags;

// Access e-commerce data
const amazonResults = item.data.shopping.amazon.results.data;

// Access AI platform data
const chatGPTResults = item.data.ai.chatgpt.results.data;

// Get key metrics
const searchVolume = item.data.max_search_volume;
const costPerClick = item.data.max_cost_per_click;
```

#### Export Formats

Results can be exported in multiple formats from the Apify platform:

- **JSON** - Full structured data with all fields
- **CSV** - Flattened data suitable for spreadsheets
- **Excel** - Formatted spreadsheet with data
- **HTML Table** - Web-ready table format
- **RSS Feed** - Automated updates via RSS

#### Integration with Make/Zapier

This actor integrates seamlessly with automation platforms:

- **Make (Integromat)**: Build automated workflows
- **Zapier**: Connect to 5,000+ apps
- **Google Sheets**: Automatically populate keyword research data
- **Airtable**: Build keyword research databases
- **Slack/Discord**: Get notifications when research completes
- **Webhooks**: Send data to custom endpoints

Example use cases:

- Monitor keyword trends daily and send reports via email
- Build automated content calendars based on trending queries
- Trigger competitor analysis when new keywords emerge
- Populate CRM with market research data

### Use Cases

- **SEO Research**: Discover popular search queries and related keywords
- **Content Planning**: Find trending topics and questions people ask
- **Market Research**: Understand what people are searching for in your niche
- **Competitor Analysis**: Research keywords your competitors might be targeting
- **PPC Campaigns**: Get cost per click estimates for keyword planning
- **Social Media Strategy**: Discover trending topics across platforms

### Advanced Features

#### Webhooks

Get notified when your actor run completes:

```javascript
const run = await client.actor("YOUR_ACTOR_ID").call(input, {
    webhooks: [{
        eventTypes: ['ACTOR.RUN.SUCCEEDED'],
        requestUrl: 'https://your-webhook-url.com/webhook'
    }]
});
```

#### Scheduled Runs

Set up recurring keyword research:

1. Go to the actor's page on Apify
2. Click "Schedule"
3. Configure frequency (hourly, daily, weekly)
4. Set your input parameters
5. Actor runs automatically on schedule

#### API Access to Results

Access your data via Apify's REST API:

```bash
## Get dataset items
curl https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN'

## Get specific fields only
curl "https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items?fields=keyword,data.max_search_volume" \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN'

## Export as CSV
curl "https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items?format=csv" \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN'
```

### Performance

- Processes each keyword in approximately 30-60 seconds
- Handles multiple keywords sequentially
- Automatic retry logic for failed searches
- Reliable data extraction
- Results stored in Apify dataset for easy access

### Support

If you encounter any issues or have questions, please [open an issue](https://apify.com/deadlyaccurate/answer-the-public/issues/open) or visit the [Apify documentation](https://docs.apify.com).

### Related Actors

- [Google Search Scraper](https://apify.com/apify/google-search-scraper)
- [YouTube Scraper](https://apify.com/bernardo/youtube-scraper)
- [Amazon Product Scraper](https://apify.com/junglee/amazon-crawler)

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Answer the Public. Each keyword will be processed with automatic account rotation.

## `language` (type: `string`):

Language code for the search (e.g., 'en' for English, 'es' for Spanish)

## `region` (type: `string`):

Region code for the search (e.g., 'us' for United States, 'uk' for United Kingdom)

## `baseEmail` (type: `string`):

Base email address for creating accounts. Will use email+random@domain.com pattern. If not provided, temporary emails will be generated.

## `maxPollAttempts` (type: `integer`):

Maximum number of attempts to poll for search completion

## `pollInterval` (type: `integer`):

Time in milliseconds between polling attempts

## Actor input object example

```json
{
  "keywords": [
    "ai tools",
    "web scraping"
  ],
  "language": "en",
  "region": "us",
  "baseEmail": "your-email@gmail.com",
  "maxPollAttempts": 60,
  "pollInterval": 5000
}
```

# 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 = {
    "keywords": [
        "ai tools",
        "web scraping"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deadlyaccurate/answer-the-public").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 = { "keywords": [
        "ai tools",
        "web scraping",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deadlyaccurate/answer-the-public").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 '{
  "keywords": [
    "ai tools",
    "web scraping"
  ]
}' |
apify call deadlyaccurate/answer-the-public --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=deadlyaccurate/answer-the-public",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Answer The Public",
        "description": "Extract comprehensive keyword research data from AnswerThePublic.com for any keyword. Get search insights from multiple sources including Google, Bing, YouTube, TikTok, Instagram, Amazon, and ChatGPT.",
        "version": "0.1",
        "x-build-id": "Kt92dfiiJBhfc4zUN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/deadlyaccurate~answer-the-public/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-deadlyaccurate-answer-the-public",
                "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/deadlyaccurate~answer-the-public/runs": {
            "post": {
                "operationId": "runs-sync-deadlyaccurate-answer-the-public",
                "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/deadlyaccurate~answer-the-public/run-sync": {
            "post": {
                "operationId": "run-sync-deadlyaccurate-answer-the-public",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Answer the Public. Each keyword will be processed with automatic account rotation.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "ru",
                            "ja",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Language code for the search (e.g., 'en' for English, 'es' for Spanish)",
                        "default": "en"
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Region code for the search (e.g., 'us' for United States, 'uk' for United Kingdom)",
                        "default": "us"
                    },
                    "baseEmail": {
                        "title": "Base Email (Optional)",
                        "type": "string",
                        "description": "Base email address for creating accounts. Will use email+random@domain.com pattern. If not provided, temporary emails will be generated."
                    },
                    "maxPollAttempts": {
                        "title": "Max Poll Attempts",
                        "minimum": 1,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum number of attempts to poll for search completion",
                        "default": 60
                    },
                    "pollInterval": {
                        "title": "Poll Interval (ms)",
                        "minimum": 1000,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Time in milliseconds between polling attempts",
                        "default": 5000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```