# Bed Bath & Beyond Scraper (`crawlerbros/bedbathandbeyond-scraper`) Actor

Scrape bedbathandbeyond.com - search by keyword or browse by home-goods department (bedding, bath, kitchen, furniture, decor, and more). Get price, sale price, brand, rating, review count, images, shipping, and rewards data with no login or proxy required.

- **URL**: https://apify.com/crawlerbros/bedbathandbeyond-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (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.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Bed Bath & Beyond Scraper

Scrape [bedbathandbeyond.com](https://www.bedbathandbeyond.com) — search by keyword or browse a home-goods department (bedding, bath, kitchen, furniture, decor, and more). Get price, sale price, brand, customer rating, review count, images, two-day-shipping eligibility, and rewards data. No login, no cookies, and no paid proxy required.

### What this actor does

- **Two modes:** `search` (free-text keyword) and `byCategory` (browse one of 16 real home-goods departments)
- **Real live pricing** in USD, including sale price, MSRP, and discount percentage
- **Ratings & reviews**, two-day-shipping flag, and Welcome Rewards cash-back data straight from the catalog
- **Filters:** price range, minimum rating, on-sale only, two-day shipping only, brand contains
- **Sort options:** relevance, on sale, best selling, price low/high, customer rating, new arrivals
- **Empty fields are omitted** — every returned field has a real value, no placeholders

### Output per product

| Field | Description |
|---|---|
| `title` | Product name |
| `brand` | Manufacturer/brand, detected from the site's own brand list for the query |
| `productId`, `sku` | Internal catalog identifiers |
| `price`, `priceMax`, `currency` | Current price (a price range's low end; `priceMax` is the high end when the product has size/color options at different prices) |
| `originalPrice` | List/MSRP price before discount |
| `discountPercent` | Percent off MSRP |
| `onSale` | Whether the product is currently marked on sale |
| `saleEndDate` | When the current sale price expires (only set when `onSale` is true) |
| `urgencyMessaging`, `valueMessaging` | Merchandising badges, e.g. "Best Seller" |
| `rating`, `reviewCount` | Average customer rating (0–5) and number of reviews |
| `optionCount` | Number of color/size variants available |
| `twoDayShipping` | Whether the product qualifies for two-day delivery |
| `rewardsAmount`, `rewardsPoints`, `rewardsPercentage` | Welcome Rewards cash-back amount, points earned, and the cash-back rate applied |
| `imageUrl`, `fullImageUrl` | Product photo (standard and full-resolution) |
| `productUrl`, `sourceUrl` | Canonical product page URL |
| `isSponsored` | Whether the listing is a sponsored placement |
| `category` | The department browsed (only set in `byCategory` mode — see Limitations) |
| `searchKeywords` | Echoes the keyword used (only set in `search` mode) |
| `recordType`, `scrapedAt` | Always `"product"` and a UTC timestamp |

### Input

| Field | Type | Mode | Description |
|---|---|---|---|
| `mode` | select | all | `search` (default) / `byCategory` |
| `keywords` | text | search | Free-text query, e.g. `towel`, `comforter set` |
| `category` | select | byCategory | One of 16 real departments (see below) |
| `sortBy` | select | all | `relevance` (default) / `onSale` / `bestSelling` / `priceLowHigh` / `priceHighLow` / `rating` / `newArrivals` |
| `minPrice` / `maxPrice` | integer | all | Price range filter (USD) |
| `minRating` | integer | all | Drop products rated below this (0–5) |
| `onSaleOnly` | boolean | all | Only emit products currently on sale |
| `fastShippingOnly` | boolean | all | Only emit two-day-shipping-eligible products |
| `brandContains` | text | all | Keep only products whose brand/title contains this text |
| `maxItems` | integer | all | Hard cap on emitted records (1–1000) |

#### Departments (`category`)

Bedding, Bath, Kitchen and Dining, Furniture, Home Decor, Storage and Organization, Home Improvement, Appliances, Baby and Kids Home Goods, Outdoor, Rugs, Housewares, Holiday, Art, Gifts, Tools.

#### Example: keyword search

```json
{
  "mode": "search",
  "keywords": "comforter set",
  "maxItems": 30
}
````

#### Example: browse a department, on-sale only, sorted by rating

```json
{
  "mode": "byCategory",
  "category": "Kitchen and Dining",
  "sortBy": "rating",
  "onSaleOnly": true,
  "maxItems": 40
}
```

#### Example: keyword search with price and shipping filters

```json
{
  "mode": "search",
  "keywords": "area rug",
  "minPrice": 50,
  "maxPrice": 300,
  "fastShippingOnly": true,
  "maxItems": 25
}
```

### Use cases

- **Price monitoring** — track sale prices and discount percentages for specific products or a whole department over time
- **Assortment research** — see what's trending / best-selling / on-sale in a given home-goods category
- **Competitive analysis** — compare Bed Bath & Beyond's catalog and pricing against other home-goods retailers
- **Content & affiliate sites** — source real product data, images, and ratings for buying guides
- **Deal aggregation** — surface on-sale, highly-rated products across departments

### Data Source & Limitations

**Domain confirmation.** `bedbathandbeyond.com` is the live, current storefront for the Bed Bath & Beyond brand — it is Overstock.com's post-bankruptcy relaunch of the brand (confirmed via the site's own asset CDN, `ak1.ostkcdn.com`, and its `ostk_*` session cookies). It is not a placeholder or defunct domain.

**Only the search endpoint is used, by design.** The site runs Akamai Bot Manager. During research we confirmed that:

- `/search?keywords=...` (plain query parameters) returns full, real catalog data via a **plain HTTPS request with no browser, no TLS impersonation, and no proxy**.
- The department-browse pages (`/c/<department>?t=<id>`) and product-detail pages (`/*/product.html`) are blocked with a `403` or an Akamai interactive JS challenge — confirmed against plain httpx, 12+ curl\_cffi browser-TLS impersonation profiles (Chrome, Edge, Safari, Firefox), **and** a real headless Playwright browser with no proxy. Per this project's zero-cost policy, residential proxy is never used to work around this.

Because of this, **`byCategory` mode is implemented as the site's own search relevance for the department name** (e.g. browsing "Bedding" issues `/search?keywords=Bedding`), not a direct taxonomy-tree traversal. The 16 departments listed above are the real, verified top-level departments returned by the site's own search-result category facet (cross-checked across multiple unrelated queries to confirm they are the stable sitewide taxonomy, not query-specific noise).

**Per-product `category` is a browse label, not upstream taxonomy metadata.** Because product-detail pages are blocked, individual search-result cards do not carry an authoritative per-product category field from the API — `category` is only populated in `byCategory` mode and reflects the department you browsed, not a value read from the product's own record.

**Brand is derived, not upstream-labeled.** Search-result cards don't include an explicit brand field either. `brand` is detected by matching the product title against the real, live brand list the site itself returns in the query's brand facet (not guessed or hardcoded) — this catches the large majority of branded products but can miss unbranded/generic listings.

**Price range products.** Some products (with multiple color/size options at different price points) show a price range on the search page; `price` is the low end and `priceMax` the high end when they differ.

**Sorting is applied client-side, to the fetched window.** We confirmed by direct testing that the site's own `sort` URL parameter (the exact link its own sort-option UI uses) is silently ignored by the server for a plain, cookie-less request — the returned page always reports "Best Matched" as the active sort regardless of what's requested; the real sort control triggers a client-side-only re-fetch we can't reproduce with a zero-cost HTTP request. To still honor your `sortBy` choice, the actor fetches results in the site's own Best-Matched relevance order and then **re-sorts the fetched window itself** for `priceLowHigh`, `priceHighLow`, `rating`, and `onSale` (on-sale items first). This re-orders what was fetched, not the entire multi-thousand-item catalog — for a true "cheapest item in the whole catalog" query, combine `sortBy: priceLowHigh` with a higher `maxItems` to widen the fetched window. `bestSelling` and `newArrivals` have no equivalent field in the search-result data, so they fall back to the fetched relevance order.

### FAQ

**Do I need a proxy or login?** No. The actor uses plain HTTPS requests against the site's public search endpoint with no cookies or authentication required.

**Why is `brand` sometimes missing?** Not every product's title contains a recognizable brand name from the site's own brand list for that query — this is expected for generic/unbranded listings, not a bug.

**Why is `category` only present in `byCategory` mode?** See "Data Source & Limitations" above — the upstream search-result API doesn't return a per-product category field, so we only populate it when you've explicitly told us which department you're browsing.

**What currency are prices in?** USD only — the site is a US retailer (a `.ca` Canadian version exists but is out of scope for this actor).

**How current is the pricing?** Live — every run fetches the current search page directly from the site.

**Are the image URLs stable?** Yes — they're served from the site's own CDN (`ak1.ostkcdn.com`) and are not signed or expiring.

# Actor input Schema

## `mode` (type: `string`):

How to find products.

## `keywords` (type: `string`):

Free-text search query, e.g. `towel`, `comforter set`, `kitchen island`.

## `category` (type: `string`):

Browse one of the site's home-goods departments. Implemented via the site's own search relevance for the department name (see README — the direct category-browse pages are blocked by the site's bot protection).

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

How results are ordered. Applied client-side to the fetched relevance-ranked result window (see README) since the upstream site's own sort control is a client-side-only feature not reproducible via a plain HTTP request.

## `minPrice` (type: `integer`):

Drop products priced below this amount.

## `maxPrice` (type: `integer`):

Drop products priced above this amount.

## `minRating` (type: `integer`):

Drop products with an average rating below this (1-5 stars).

## `onSaleOnly` (type: `boolean`):

Only emit products currently marked on sale.

## `fastShippingOnly` (type: `boolean`):

Only emit products eligible for two-day delivery.

## `brandContains` (type: `string`):

Keep only products whose detected brand or title contains this text (case-insensitive), e.g. `Superior`, `SAFAVIEH`, `KitchenAid`.

## `maxItems` (type: `integer`):

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": "bedding",
  "category": "Bedding",
  "sortBy": "relevance",
  "onSaleOnly": false,
  "fastShippingOnly": false,
  "brandContains": "",
  "maxItems": 30
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped products.

# 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 = {
    "mode": "search",
    "keywords": "bedding",
    "category": "Bedding",
    "sortBy": "relevance",
    "onSaleOnly": false,
    "fastShippingOnly": false,
    "brandContains": "",
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/bedbathandbeyond-scraper").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 = {
    "mode": "search",
    "keywords": "bedding",
    "category": "Bedding",
    "sortBy": "relevance",
    "onSaleOnly": False,
    "fastShippingOnly": False,
    "brandContains": "",
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/bedbathandbeyond-scraper").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 '{
  "mode": "search",
  "keywords": "bedding",
  "category": "Bedding",
  "sortBy": "relevance",
  "onSaleOnly": false,
  "fastShippingOnly": false,
  "brandContains": "",
  "maxItems": 30
}' |
apify call crawlerbros/bedbathandbeyond-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bed Bath & Beyond Scraper",
        "description": "Scrape bedbathandbeyond.com - search by keyword or browse by home-goods department (bedding, bath, kitchen, furniture, decor, and more). Get price, sale price, brand, rating, review count, images, shipping, and rewards data with no login or proxy required.",
        "version": "1.0",
        "x-build-id": "clFs4jLTmup91GDHe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~bedbathandbeyond-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-bedbathandbeyond-scraper",
                "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/crawlerbros~bedbathandbeyond-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-bedbathandbeyond-scraper",
                "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/crawlerbros~bedbathandbeyond-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-bedbathandbeyond-scraper",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory"
                        ],
                        "type": "string",
                        "description": "How to find products.",
                        "default": "search"
                    },
                    "keywords": {
                        "title": "Search keywords (mode=search)",
                        "type": "string",
                        "description": "Free-text search query, e.g. `towel`, `comforter set`, `kitchen island`.",
                        "default": ""
                    },
                    "category": {
                        "title": "Department / category (mode=byCategory)",
                        "enum": [
                            "Bedding",
                            "Bath",
                            "Kitchen and Dining",
                            "Furniture",
                            "Home Decor",
                            "Storage and Organization",
                            "Home Improvement",
                            "Appliances",
                            "Baby and Kids Home Goods",
                            "Outdoor",
                            "Rugs",
                            "Housewares",
                            "Holiday",
                            "Art",
                            "Gifts",
                            "Tools"
                        ],
                        "type": "string",
                        "description": "Browse one of the site's home-goods departments. Implemented via the site's own search relevance for the department name (see README — the direct category-browse pages are blocked by the site's bot protection).",
                        "default": "Bedding"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "onSale",
                            "bestSelling",
                            "priceLowHigh",
                            "priceHighLow",
                            "rating",
                            "newArrivals"
                        ],
                        "type": "string",
                        "description": "How results are ordered. Applied client-side to the fetched relevance-ranked result window (see README) since the upstream site's own sort control is a client-side-only feature not reproducible via a plain HTTP request.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Drop products priced below this amount."
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Drop products priced above this amount."
                    },
                    "minRating": {
                        "title": "Minimum customer rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop products with an average rating below this (1-5 stars)."
                    },
                    "onSaleOnly": {
                        "title": "On-sale products only",
                        "type": "boolean",
                        "description": "Only emit products currently marked on sale.",
                        "default": false
                    },
                    "fastShippingOnly": {
                        "title": "Two-day shipping only",
                        "type": "boolean",
                        "description": "Only emit products eligible for two-day delivery.",
                        "default": false
                    },
                    "brandContains": {
                        "title": "Brand contains",
                        "type": "string",
                        "description": "Keep only products whose detected brand or title contains this text (case-insensitive), e.g. `Superior`, `SAFAVIEH`, `KitchenAid`.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
