# Google Shopping Scraper — Product Prices, Ratings & Sellers (`junipr/google-shopping`) Actor

Scrape Google Shopping search results. Extract product titles, prices, ratings, seller info, delivery details, and product URLs. Support for multiple countries, pagination, and direct product URLs.

- **URL**: https://apify.com/junipr/google-shopping.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.60 / 1,000 product scrapeds

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

## Google Shopping Scraper

Extract product pricing, ratings, merchant info, and delivery data from Google Shopping at scale. Monitor competitor prices, build comparison tables, and track market trends with structured data exports. Works across 30+ countries with automatic currency detection and multi-language support.

Google Shopping Scraper is built for e-commerce professionals who need reliable, structured product data without the overhead of building and maintaining their own scraping infrastructure. Whether you're tracking competitor pricing daily, building a price comparison tool, or researching market trends, this actor gives you clean, analysis-ready data in seconds.

### What Data Can You Extract?

| Field | Description |
|-------|-------------|
| `title` | Product title |
| `price.current` | Current price as a **numeric value** (not a string) |
| `price.original` | Pre-discount price when on sale |
| `price.currency` | ISO 4217 currency code (USD, EUR, GBP, etc.) |
| `price.discountPercent` | Calculated discount percentage |
| `price.priceRange` | Min/max price for variant products |
| `merchant.name` | Seller/merchant name |
| `merchant.rating` | Merchant rating (0-5) |
| `merchant.reviewCount` | Number of merchant reviews |
| `merchant.isVerified` | Google-verified merchant status |
| `productRating.value` | Product star rating (0-5) |
| `productRating.count` | Number of product reviews |
| `delivery.free` | Whether shipping is free |
| `delivery.cost` | Shipping cost as numeric value |
| `delivery.estimatedDate` | Expected delivery date |
| `brand` | Brand name |
| `gtin` | Global Trade Item Number (barcode) |
| `mpn` | Manufacturer Part Number |
| `isSponsored` | Whether the listing is a paid ad |
| `thumbnailUrl` | Product image URL |
| `badges` | Special labels like "Best Seller", "Top Quality Store" |

All price fields are returned as **numeric values** ready for calculations, sorting, and database storage — not raw strings that require additional parsing.

### How to Use

**Zero-config start** — just provide a product query:

```json
{
  "queries": ["wireless headphones"]
}
````

That's it. The actor will search Google Shopping and return up to 20 structured product listings with pricing, ratings, merchant info, and delivery details.

**Using the Apify API:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('junipr/google-shopping').call({
    queries: ['iPhone 15 Pro', 'Samsung Galaxy S24'],
    country: 'us',
    resultsPerQuery: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} products`);
```

### Input Configuration

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `queries` | string\[] | — | Product search queries (max 100) |
| `urls` | string\[] | — | Direct Google Shopping URLs (max 100) |
| `country` | string | `"us"` | Country code (us, gb, de, fr, au, ca, etc.) |
| `language` | string | `"en"` | Language code (en, de, fr, es, etc.) |
| `resultsPerQuery` | integer | `20` | Products per query (1-100) |
| `paginate` | boolean | `false` | Enable multi-page scraping |
| `maxResultsPerQuery` | integer | `60` | Max products when paginating (1-500) |
| `sortBy` | string | `"relevance"` | Sort: relevance, price\_low, price\_high, rating |
| `minPrice` | number | — | Minimum price filter |
| `maxPrice` | number | — | Maximum price filter |
| `condition` | string | `"all"` | Product condition: all, new, used, refurbished |
| `includeSponsored` | boolean | `true` | Include sponsored/ad listings |

**Common configurations:**

Price range filter:

```json
{ "queries": ["coffee machine"], "minPrice": 50, "maxPrice": 200 }
```

Multi-country comparison:

```json
{ "queries": ["laptop"], "country": "de", "language": "de" }
```

### Output Format

Each product is a structured JSON object:

```json
{
  "query": "wireless headphones",
  "position": 1,
  "isSponsored": false,
  "title": "Sony WH-1000XM5 Wireless Noise Canceling Headphones",
  "brand": "Sony",
  "price": {
    "current": 279.99,
    "original": 399.99,
    "currency": "USD",
    "currencySymbol": "$",
    "priceString": "$279.99",
    "discountPercent": 30,
    "priceRange": { "min": null, "max": null }
  },
  "merchant": {
    "name": "Best Buy",
    "rating": 4.7,
    "reviewCount": 12453,
    "isVerified": true
  },
  "productRating": {
    "value": 4.5,
    "count": 8234,
    "countLabel": "8,234 reviews"
  },
  "delivery": {
    "free": true,
    "cost": 0,
    "estimatedDate": "Fri, Apr 4"
  },
  "country": "us",
  "scrapedAt": "2025-04-01T12:00:00.000Z"
}
```

### Use Cases

- **E-commerce price monitoring** — Track competitor prices daily with scheduled runs. Get alerts when prices drop below thresholds.
- **Brand protection** — Find unauthorized resellers listing your products on Google Shopping. Cross-reference GTINs to identify gray market sellers.
- **Market research** — Analyze pricing trends across categories, countries, and time periods. Compare merchant distribution and market share.
- **Procurement benchmarking** — Research supplier pricing before negotiations. Compare the same product across dozens of merchants instantly.
- **Price comparison tools** — Feed structured product data into your comparison engine. Numeric prices and currency codes are ready for direct use.
- **Dropshipping research** — Find pricing benchmarks and profit margins by comparing wholesale vs retail prices across merchants.

### Pricing

**Pay-Per-Event: $2.60 per 1,000 products scraped.**

Pricing includes all platform compute costs — no hidden fees.

You only pay for successfully extracted products. Failed pages, blocked requests, and queries with zero results are not billed.

| Scenario | Products | Cost |
|----------|----------|------|
| Single query (20 products) | 20 | $0.05 |
| Daily price check (50 products) | 500 | $1.30 |
| Weekly market research (6,000 products) | 6,000 | $15.60 |
| Comprehensive catalog (30,000 products) | 30,000 | $78.00 |

Compared to SerpAPI Google Shopping ($50+ per 1,000 results), this actor is **19x more affordable** while providing richer data fields including delivery info, merchant ratings, and product identifiers.

### FAQ

#### Why does Google Shopping require residential proxies?

Google Shopping aggressively blocks datacenter IP addresses. Residential proxies mimic real user traffic from home internet connections, which Google does not block. This actor defaults to Apify's residential proxy network, which requires a paid Apify plan ($49+/month). Free-plan users can provide their own residential proxy URL in the input configuration.

#### How accurate are the prices?

All prices are parsed into numeric values with 100% accuracy on the numeric conversion. The actor handles multiple price formats including US ($1,234.56), European (1.234,56), and various currency symbols. If a price cannot be parsed, `price.current` is set to `null` and the raw `priceString` is preserved for manual review.

#### Can I monitor prices over time with scheduled runs?

Yes. Set up a scheduled run on Apify (daily, hourly, weekly) with your product queries. Each run produces a new dataset. Use Apify's webhook integrations to pipe results to Google Sheets, a database, or your own API for trend analysis.

#### Does it work for all countries?

Google Shopping is available in 30+ countries. The actor supports all of them via the `country` parameter. Popular markets include US, UK, Germany, France, Australia, Canada, Japan, India, and Brazil. Currency and language are automatically configured based on the country code.

#### What happens when Google changes its layout?

The actor uses multiple fallback selectors and robust parsing logic to handle layout variations. If Google makes a major structural change, the actor will log a `PARSE_ERROR` and continue attempting extraction with alternative selectors. We monitor for breaking changes and push updates quickly.

#### Can I filter by condition (new/used/refurbished)?

Yes. Set the `condition` parameter to `"new"`, `"used"`, or `"refurbished"` to filter results. The default is `"all"` which shows products in any condition.

#### How do I get all seller offers for a product?

Use the `paginate` option with `maxResultsPerQuery` set to a higher value (e.g., 100-500). This retrieves more results which often include multiple merchants selling the same product. You can then group results by `productId` or `gtin` to see all available offers.

#### Is scraping Google Shopping legal?

Google Shopping results are publicly accessible to any anonymous user. The hiQ v. LinkedIn Supreme Court precedent established that scraping publicly accessible data may be protected. However, this actor should be used responsibly and in compliance with applicable laws and Google's Terms of Service. Users are responsible for ensuring their use case complies with local regulations.

# Actor input Schema

## `queries` (type: `array`):

Product search queries to look up on Google Shopping. E.g. \["iPhone 15 Pro", "Sony WH-1000XM5"]. Max 100 queries per run.

## `urls` (type: `array`):

Direct Google Shopping search result URLs. Must contain google.com/search with shopping parameters. Max 100 URLs.

## `country` (type: `string`):

Country code (ISO 3166-1 alpha-2) for Google Shopping market. Determines currency, merchants, and pricing. Examples: us, gb, de, fr, au, ca.

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

Language code (ISO 639-1) for search results. Examples: en, de, fr, es, ja.

## `currency` (type: `string`):

Force currency display (ISO 4217). Leave empty for country default. Examples: USD, EUR, GBP.

## `resultsPerQuery` (type: `integer`):

Number of products to extract per query (without pagination). Min: 1, Max: 100.

## `paginate` (type: `boolean`):

Paginate through all result pages to get more products. Respects maxResultsPerQuery limit.

## `maxResultsPerQuery` (type: `integer`):

Maximum products to extract per query when pagination is enabled. Min: 1, Max: 500.

## `sortBy` (type: `string`):

Sort order for search results.

## `minPrice` (type: `number`):

Minimum price filter in local currency. Leave empty for no minimum.

## `maxPrice` (type: `number`):

Maximum price filter in local currency. Leave empty for no maximum.

## `condition` (type: `string`):

Filter products by condition.

## `includeSponsored` (type: `boolean`):

Include sponsored/ad listings in results.

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

Residential proxy is required — Google blocks datacenter IPs for Shopping results. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.

## Actor input object example

```json
{
  "queries": [
    "wireless headphones"
  ],
  "country": "us",
  "language": "en",
  "resultsPerQuery": 20,
  "paginate": false,
  "maxResultsPerQuery": 60,
  "sortBy": "relevance",
  "condition": "all",
  "includeSponsored": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped Google Shopping product listings with structured pricing, merchant details, ratings, delivery info, and product identifiers.

# 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 = {
    "queries": [
        "wireless headphones"
    ],
    "country": "us",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/google-shopping").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 = {
    "queries": ["wireless headphones"],
    "country": "us",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("junipr/google-shopping").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 '{
  "queries": [
    "wireless headphones"
  ],
  "country": "us",
  "language": "en"
}' |
apify call junipr/google-shopping --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Shopping Scraper — Product Prices, Ratings & Sellers",
        "description": "Scrape Google Shopping search results. Extract product titles, prices, ratings, seller info, delivery details, and product URLs. Support for multiple countries, pagination, and direct product URLs.",
        "version": "1.0",
        "x-build-id": "N6sy25PqjNT99Glfm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~google-shopping/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-google-shopping",
                "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/junipr~google-shopping/runs": {
            "post": {
                "operationId": "runs-sync-junipr-google-shopping",
                "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/junipr~google-shopping/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-google-shopping",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Product search queries to look up on Google Shopping. E.g. [\"iPhone 15 Pro\", \"Sony WH-1000XM5\"]. Max 100 queries per run.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "wireless headphones"
                        ]
                    },
                    "urls": {
                        "title": "Google Shopping URLs",
                        "type": "array",
                        "description": "Direct Google Shopping search result URLs. Must contain google.com/search with shopping parameters. Max 100 URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country code (ISO 3166-1 alpha-2) for Google Shopping market. Determines currency, merchants, and pricing. Examples: us, gb, de, fr, au, ca.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language code (ISO 639-1) for search results. Examples: en, de, fr, es, ja.",
                        "default": "en"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Force currency display (ISO 4217). Leave empty for country default. Examples: USD, EUR, GBP."
                    },
                    "resultsPerQuery": {
                        "title": "Results Per Query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of products to extract per query (without pagination). Min: 1, Max: 100.",
                        "default": 20
                    },
                    "paginate": {
                        "title": "Paginate",
                        "type": "boolean",
                        "description": "Paginate through all result pages to get more products. Respects maxResultsPerQuery limit.",
                        "default": false
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results Per Query (Paginated)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum products to extract per query when pagination is enabled. Min: 1, Max: 500.",
                        "default": 60
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "price_low",
                            "price_high",
                            "rating",
                            "review_count"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum Price",
                        "type": "number",
                        "description": "Minimum price filter in local currency. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Maximum Price",
                        "type": "number",
                        "description": "Maximum price filter in local currency. Leave empty for no maximum."
                    },
                    "condition": {
                        "title": "Product Condition",
                        "enum": [
                            "all",
                            "new",
                            "used",
                            "refurbished"
                        ],
                        "type": "string",
                        "description": "Filter products by condition.",
                        "default": "all"
                    },
                    "includeSponsored": {
                        "title": "Include Sponsored",
                        "type": "boolean",
                        "description": "Include sponsored/ad listings in results.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxy is required — Google blocks datacenter IPs for Shopping results. Defaults to Apify residential proxy (requires paid Apify plan). Free-plan users can provide their own residential proxy URL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```