# Google Shopping Scraper (Cheap) (`data_api/google-shopping-scraper-cheap`) Actor

Google Shopping scraper that collects product listings, prices, discounts, ratings, and retailer info by search query, so you can monitor competitor prices, track deals, and build product catalogs without manual lookup.

- **URL**: https://apify.com/data\_api/google-shopping-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Shopping Product Scraper

![Google Shopping Product Scraper](cover.jpg)

Comparing prices on Google Shopping by hand is slow work: you scroll page after page, copy a name here, a price there, squint at which retailer is actually cheapest. This scraper does the reading for you. Type a search term and it walks the Google Shopping results, then hands back every product as a clean row — name, current price, the pre-discount price, the worked-out discount, star rating, review count, retailer, shipping note, and image. Set a price band, ask for sale items only, point it at any country, and only pay for the products you pull.

### What you get

Each product comes back as one row with a steady shape, so results drop straight into a sheet, database, or pricing model. Fields split into three groups:

- **Product** — `itemName`, `productCode`, `itemUrl`, `imageLink`, `metadataTags`, `isUsed`, `usedCondition`
- **Pricing** — `priceLabel`, `currentPrice`, `listPriceLabel`, `listPrice`, `discountRate`, `promoBadge`
- **Seller and reputation** — `sellerName`, `sellerIconUrl`, `multipleSellers`, `starRating`, `reviewsTotal`, `reviewSummary`, `deliveryInfo`, plus `resultRank`, `searchTerm`, and `collectedAt`

### Quick start

1. Hit **Try for free** and open the input form.
2. Type what you're after into **Search term** (for example `wireless earbuds`).
3. Optional: set a **Lowest price** / **Highest price** band, flip on **On sale only**, or pick a **Target country**.
4. Set a **Results limit**, press **Start**, then export as JSON, CSV, Excel, or XML when the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Price monitoring** — track what a product sells for across retailers and catch drops as they happen
- **Competitor research** — see who lists a category, at what price, and with what rating
- **Deal hunting** — filter to sale items and sort cheapest-first to surface the best offers
- **Catalog building** — turn a search term into a structured product feed with prices and images
- **Market analysis** — compare pricing and availability across countries and Google domains

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchTerm` | string | Yes | What to look up on Google Shopping, e.g. `wireless earbuds` or `samsung galaxy s24`. Prefilled with `wireless earbuds`. |
| `minPriceFilter` | integer | No | Drop anything priced below this value. Leave blank for no floor. |
| `maxPriceFilter` | integer | No | Drop anything priced above this value. Leave blank for no ceiling. |
| `sortOrder` | string | No | `0` best match, `1` cheapest first, `2` most expensive first. Default `0`. |
| `onlyFreeShipping` | boolean | No | Keep only products that ship for free. Default `false`. |
| `onlyOnSale` | boolean | No | Keep only products with an active discount. Default `false`. |
| `deviceType` | string | No | Emulate a `desktop` or `mobile` visitor. Default `desktop`. |
| `languageCode` | string | No | Two-letter result language such as `en`, `de`, or `fr`. Default `en`. |
| `countryCode` | string | No | Two-letter country code for geo-targeting such as `us`, `gb`, or `de`. Default `us`. |
| `googleHost` | string | No | Google domain to query, e.g. `google.co.uk` or `google.de`. Default `google.com`. |
| `locationName` | string | No | Place name for finer geo-targeting, e.g. `Seattle, Washington, United States`. Overrides `countryCode` when set. |
| `resultsLimit` | integer | No | Most products to return per run. Default `25`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before timing out. Default `45`. |

#### Example input

```json
{
  "searchTerm": "wireless earbuds",
  "minPriceFilter": 30,
  "maxPriceFilter": 200,
  "sortOrder": "1",
  "onlyFreeShipping": true,
  "languageCode": "en",
  "countryCode": "us",
  "resultsLimit": 25,
  "timeoutSeconds": 45
}
````

### Output

Every matched product becomes one row. Results paginate automatically up to your `resultsLimit`, duplicates across pages are dropped, and fields a listing does not expose come back as `null` so your columns stay predictable.

#### Example output

```json
{
  "resultRank": 1,
  "productCode": "14665440674095220111",
  "itemName": "Sony WF-1000XM5 Wireless Noise-Cancelling Earbuds",
  "itemUrl": "https://www.google.com/shopping/product/1234567890",
  "sellerName": "Best Buy",
  "sellerIconUrl": "https://encrypted-tbn0.gstatic.com/favicon-bestbuy.png",
  "priceLabel": "$248.00",
  "currentPrice": 248.0,
  "listPriceLabel": "$299.99",
  "listPrice": 299.99,
  "discountRate": 17.3,
  "promoBadge": "17% off",
  "starRating": 4.6,
  "reviewsTotal": 5821,
  "reviewSummary": "Superb noise cancelling and a comfortable fit",
  "deliveryInfo": "Free delivery",
  "metadataTags": ["Noise cancelling", "Bluetooth 5.3"],
  "imageLink": "https://encrypted-tbn1.gstatic.com/images?q=example",
  "isUsed": false,
  "usedCondition": null,
  "multipleSellers": true,
  "searchTerm": "wireless earbuds",
  "collectedAt": "2026-06-29T12:00:00.000000+00:00",
  "errorMessage": null
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `resultRank` | number | Position of the product within the results |
| `productCode` | string | Google product identifier |
| `itemName` | string | Product name |
| `itemUrl` | string | Link to the Google Shopping product page |
| `sellerName` | string | Retailer offering the item |
| `sellerIconUrl` | string | Retailer favicon link |
| `priceLabel` | string | Price exactly as shown, e.g. `$248.00` |
| `currentPrice` | number | Price as a number |
| `listPriceLabel` | string | Pre-discount price as shown |
| `listPrice` | number | Pre-discount price as a number |
| `discountRate` | number | Worked-out discount percentage |
| `promoBadge` | string | Deal or promotion badge |
| `starRating` | number | Average rating out of five |
| `reviewsTotal` | number | How many reviews were left |
| `reviewSummary` | string | Brief review excerpt |
| `deliveryInfo` | string | Shipping and returns note |
| `metadataTags` | array | Extra badges and metadata tags |
| `imageLink` | string | Product image as a link or base64 data URI |
| `isUsed` | boolean | True for a used or refurbished item |
| `usedCondition` | string | Used-condition label, e.g. `Refurbished` |
| `multipleSellers` | boolean | True when several retailers carry the item |
| `searchTerm` | string | The search term that produced the row |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |
| `errorMessage` | string | Failure reason for the row; `null` on success |

### Tips for best results

- **Start small.** Run a `resultsLimit` of 25 first to confirm the output fits your pipeline, then raise it for the full pull.
- **Narrow with a price band.** Setting `minPriceFilter` and `maxPriceFilter` cuts out noise and keeps the rows on target.
- **Match the market.** Pair `countryCode`, `languageCode`, and `googleHost` (e.g. `gb` + `en` + `google.co.uk`) so prices come back in the right currency and locale.
- **Use `locationName` for city-level reads.** A place like `New York, New York, United States` targets tighter than a country code alone.
- **Raise `timeoutSeconds`** toward 60 on large pulls or slower connections if you see requests time out.

### How can I use Google Shopping product data?

**How can I use the Google Shopping Product Scraper to monitor prices across retailers?**
Run your search term on a schedule and each product comes back with `currentPrice`, `listPriceLabel`, `discountRate`, and `sellerName`. Compare rows over time to chart price moves, and use `multipleSellers` to see when the same item is listed by more than one retailer.

**How can I scrape Google Shopping deals and discounts?**
Set `onlyOnSale` to `true` and `sortOrder` to cheapest-first. The scraper keeps only discounted products and surfaces the lowest prices, with `promoBadge`, `listPrice`, and `discountRate` spelling out the saving on every row.

**How can I build a product catalog or pricing dataset from Google Shopping?**
Feed in a search term, set `resultsLimit` to the volume you need, and export to CSV or Excel. Each row carries `itemName`, `productCode`, `currentPrice`, `starRating`, `reviewsTotal`, and `imageLink` — a ready-made feed you can load into a sheet, store, or pricing model.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `searchTerm` (type: `string`):

What to look up on Google Shopping. Try things like 'wireless earbuds', 'adidas trainers', or 'samsung galaxy s24'.

## `minPriceFilter` (type: `integer`):

Skip anything below this price. Leave blank to keep the floor open.

## `maxPriceFilter` (type: `integer`):

Skip anything above this price. Leave blank for no ceiling.

## `sortOrder` (type: `string`):

How the matched products should be ordered.

## `onlyFreeShipping` (type: `boolean`):

Keep only products that ship for free.

## `onlyOnSale` (type: `boolean`):

Keep only products with an active discount.

## `deviceType` (type: `string`):

Render results as a desktop or mobile visitor would see them.

## `languageCode` (type: `string`):

Two-letter language code for the listings, such as 'en', 'de', 'fr', or 'tr'.

## `countryCode` (type: `string`):

Two-letter country code used for geo-targeting, such as 'us', 'gb', or 'de'.

## `googleHost` (type: `string`):

Which Google domain to query, such as 'google.co.uk', 'google.de', or 'google.com.tr'.

## `locationName` (type: `string`):

Place name for finer geo-targeting, e.g. 'Seattle, Washington, United States'. Takes priority over the country code when filled in.

## `resultsLimit` (type: `integer`):

Most products to bring back in a single run.

## `timeoutSeconds` (type: `integer`):

Seconds to wait on each request before it times out.

## Actor input object example

```json
{
  "searchTerm": "wireless earbuds",
  "sortOrder": "0",
  "onlyFreeShipping": false,
  "onlyOnSale": false,
  "deviceType": "desktop",
  "languageCode": "en",
  "countryCode": "us",
  "googleHost": "google.com",
  "resultsLimit": 25,
  "timeoutSeconds": 45
}
```

# 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 = {
    "searchTerm": "wireless earbuds",
    "languageCode": "en",
    "countryCode": "us",
    "googleHost": "google.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/google-shopping-scraper-cheap").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 = {
    "searchTerm": "wireless earbuds",
    "languageCode": "en",
    "countryCode": "us",
    "googleHost": "google.com",
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/google-shopping-scraper-cheap").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 '{
  "searchTerm": "wireless earbuds",
  "languageCode": "en",
  "countryCode": "us",
  "googleHost": "google.com"
}' |
apify call data_api/google-shopping-scraper-cheap --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Shopping Scraper (Cheap)",
        "description": "Google Shopping scraper that collects product listings, prices, discounts, ratings, and retailer info by search query, so you can monitor competitor prices, track deals, and build product catalogs without manual lookup.",
        "version": "0.0",
        "x-build-id": "6d9CvTQbHpR9k6m5f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~google-shopping-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-google-shopping-scraper-cheap",
                "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/data_api~google-shopping-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-google-shopping-scraper-cheap",
                "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/data_api~google-shopping-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-google-shopping-scraper-cheap",
                "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": [
                    "searchTerm"
                ],
                "properties": {
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "What to look up on Google Shopping. Try things like 'wireless earbuds', 'adidas trainers', or 'samsung galaxy s24'."
                    },
                    "minPriceFilter": {
                        "title": "Lowest price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip anything below this price. Leave blank to keep the floor open."
                    },
                    "maxPriceFilter": {
                        "title": "Highest price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip anything above this price. Leave blank for no ceiling."
                    },
                    "sortOrder": {
                        "title": "Result order",
                        "enum": [
                            "0",
                            "1",
                            "2"
                        ],
                        "type": "string",
                        "description": "How the matched products should be ordered.",
                        "default": "0"
                    },
                    "onlyFreeShipping": {
                        "title": "Free shipping only",
                        "type": "boolean",
                        "description": "Keep only products that ship for free.",
                        "default": false
                    },
                    "onlyOnSale": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Keep only products with an active discount.",
                        "default": false
                    },
                    "deviceType": {
                        "title": "Browser to emulate",
                        "enum": [
                            "desktop",
                            "mobile"
                        ],
                        "type": "string",
                        "description": "Render results as a desktop or mobile visitor would see them.",
                        "default": "desktop"
                    },
                    "languageCode": {
                        "title": "Result language",
                        "type": "string",
                        "description": "Two-letter language code for the listings, such as 'en', 'de', 'fr', or 'tr'.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Target country",
                        "type": "string",
                        "description": "Two-letter country code used for geo-targeting, such as 'us', 'gb', or 'de'.",
                        "default": "us"
                    },
                    "googleHost": {
                        "title": "Google domain",
                        "type": "string",
                        "description": "Which Google domain to query, such as 'google.co.uk', 'google.de', or 'google.com.tr'.",
                        "default": "google.com"
                    },
                    "locationName": {
                        "title": "Location",
                        "type": "string",
                        "description": "Place name for finer geo-targeting, e.g. 'Seattle, Washington, United States'. Takes priority over the country code when filled in."
                    },
                    "resultsLimit": {
                        "title": "Results limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Most products to bring back in a single run.",
                        "default": 25
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Seconds to wait on each request before it times out.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
