# At Home Scraper - Furniture, Decor & Rugs (`crawlerbros/athome-scraper`) Actor

Scrape At Home (athome.com), the US home-decor superstore. Search products by keyword, browse by department (Furniture, Rugs, Lighting, Outdoor, and more), or fetch by direct product URL. Get prices, sale status, images, dimensions, ratings, and full category breadcrumbs.

- **URL**: https://apify.com/crawlerbros/athome-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Agents
- **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

## At Home Scraper

Scrape **At Home** (athome.com) — the US home-decor superstore chain with a massive catalog of furniture, wall art, rugs, kitchen & dining, outdoor, seasonal/holiday, lighting, and bed & bath products. Search by keyword, browse by department, or fetch specific products by URL. Get prices, sale status, images, dimensions, materials, ratings, and full category breadcrumbs. HTTP-only, no auth, no login, no cookies required.

### What this actor does

- **Three modes:** `search` (keyword), `byCategory` (department browse), `byUrls` (direct product lookup)
- **12 departments:** Furniture, Outdoor, Rugs, Wall Art & Mirrors, Decor, Pillows, Kitchen & Dining, Bed & Bath, Window, Lighting, Storage & Organization, Holiday & Seasonal
- **Filters:** price range, minimum rating, on-sale only, in-stock only, color, material
- **Sort:** relevance, price (asc/desc), rating, popularity (review count), newest
- **Empty fields are omitted** — a record only ever contains fields that have real data

### Output per product

- `title` — product name
- `sku` — At Home's product/item number
- `brand` — usually "At Home" (private label)
- `price`, `priceCurrency` — current selling price
- `isOnSale` — `true` if the current price is a markdown from list price
- `availability` — e.g. "In Stock", "Out of Stock"
- `itemCondition` — e.g. "New"
- `images[]` — product photo URLs
- `description`
- `color` — swatch color name, for items sold in multiple colors (e.g. pillows, throws)
- `colorSwatchUrl` — thumbnail image of the color swatch, when available
- `widthIn`, `depthIn`, `heightIn` — parsed dimensions in inches
- `dimensions` — combined human-readable size string
- `weightLbs`
- `material`
- `rating`, `reviewCount`
- `category`, `subcategory` — from the product's own breadcrumb trail
- `breadcrumb[]` — full category trail
- `variantUrls[]` — other size/color variant product pages, for items sold in multiple sizes (e.g. rugs)
- `returnPolicyDays`, `returnFree` — At Home's return policy for the item
- `sourceUrl` — canonical athome.com product URL
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCategory` / `byUrls` |
| `searchQuery` | string | `rug` | Keyword(s) to search product titles for (mode=search) |
| `department` | string | `furniture` | Department to browse (mode=byCategory) |
| `productUrls` | array | – | Direct athome.com product URLs (mode=byUrls) |
| `minPrice` / `maxPrice` | int | – | USD price range (0 = no bound) |
| `minRating` | int | – | Minimum star rating (0-5) |
| `color` | string | – | Only products whose color contains this text (case-insensitive) |
| `material` | string | – | Only products whose material contains this text (case-insensitive) |
| `onSaleOnly` | bool | `false` | Only products with a markdown price |
| `inStockOnly` | bool | `false` | Only in-stock products |
| `sortBy` | string | `relevance` | `relevance` / `price-asc` / `price-desc` / `rating-desc` / `popularity-desc` / `newest` |
| `maxItems` | int | `20` | Hard cap on returned products (1-1000) |
| `proxyConfiguration` | object | AUTO | Optional — used only as an automatic fallback |

#### Example: keyword search

```json
{
  "mode": "search",
  "searchQuery": "table lamp",
  "maxItems": 30,
  "sortBy": "price-asc"
}
````

#### Example: browse a department, on-sale only

```json
{
  "mode": "byCategory",
  "department": "rugs",
  "onSaleOnly": true,
  "maxItems": 25
}
```

#### Example: fetch specific products by URL

```json
{
  "mode": "byUrls",
  "productUrls": [
    {"url": "https://www.athome.com/mr.-clean-angle-broom/123569083.html"}
  ]
}
```

#### Example: price-filtered furniture search

```json
{
  "mode": "byCategory",
  "department": "furniture",
  "minPrice": 100,
  "maxPrice": 500,
  "minRating": 4,
  "sortBy": "rating-desc"
}
```

### Use cases

- **Price monitoring** — track sale/list price changes on home-decor products over time
- **Assortment research** — analyze At Home's catalog breadth by department
- **Competitive intelligence** — compare pricing and ratings against other home-goods retailers
- **Merchandising & trend analysis** — see which categories carry the most highly-rated items
- **Dropshipping / resale research** — bulk-export product data with dimensions, materials, and images

### FAQ

**Is this the official At Home API?**
No — this is an independent, third-party actor that reads publicly available product pages on athome.com. It is not affiliated with or endorsed by At Home.

**Why are `search` and `byCategory` client-side rather than using At Home's own search/browse pages?**
athome.com's search and category pages are not reliably reachable by automated tools, so this actor discovers products through the site's own public sitemap and reads each product's full page directly — the same page a shopper would see, just fetched without a browser.

**Why don't some sale items show an "original price"?**
At Home's product pages expose the current selling price and whether it's a sale price, but not the pre-markdown price in the page's structured data — so we don't fabricate one.

**Does the data include color?**
When an item is sold in multiple colors (e.g. a pillow or throw), each color's own product page exposes a `color` name and swatch thumbnail, which this actor captures. Items that only come in one option (most furniture, decor) don't have a separate color field. Size variants are exposed as `variantUrls` — sibling product pages for the item's other available sizes.

**How fresh is the data?**
Every run fetches live product pages — prices, stock, and ratings reflect what's on athome.com at run time.

**Does this actor need a proxy or login?**
No. It works out of the box with no cookies, no login, and no residential proxy. An optional datacenter proxy is used automatically only as a fallback if a fetch is briefly rate-limited.

**Why might `byCategory` return fewer than `maxItems`?**
Department matching is verified against each product's real category, and very specific departments may have a smaller catalog than `maxItems` requests, or the item is discontinued. Widen the department or lower `maxItems`.

# Actor input Schema

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

What to fetch: keyword search across product titles, browse a department, or fetch specific products by URL.

## `searchQuery` (type: `string`):

Free-text keyword(s) to search for in product titles, e.g. 'rug', 'table lamp', 'throw pillow' (mode=search). Matches against the full product catalog.

## `department` (type: `string`):

Home-decor department to browse (mode=byCategory). Results are verified against each product's real category breadcrumb.

## `productUrls` (type: `array`):

Direct athome.com product page URLs to fetch, e.g. https://www.athome.com/mr.-clean-angle-broom/123569083.html.

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

Only return products priced at or above this amount. 0 means no minimum. Applied client-side after fetch.

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

Only return products priced at or below this amount. 0 means no maximum. Applied client-side after fetch.

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

Only return products rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Products with no rating are excluded once this is set above 0.

## `color` (type: `string`):

Only return products whose color contains this text (case-insensitive), e.g. 'blue', 'ivory', 'black'. Only some athome.com products (e.g. pillows, throws) expose a color attribute -- products without one always pass this filter.

## `material` (type: `string`):

Only return products whose material contains this text (case-insensitive), e.g. 'wood', 'metal', 'polyester', 'glass'. Most athome.com products expose a material attribute -- products without one always pass this filter.

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

Only return products currently marked with a sale price.

## `inStockOnly` (type: `boolean`):

Only return products currently in stock.

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

How to order results after fetching. athome.com's own search/browse pages aren't reachable server-side, so sorting is applied client-side across the fetched batch.

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

Hard cap on the number of products to return.

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

Optional. Product pages are reliably reachable without a proxy; this is used only as an automatic fallback if a fetch is transiently blocked.

## Actor input object example

```json
{
  "mode": "byUrls",
  "searchQuery": "rug",
  "department": "furniture",
  "productUrls": [
    {
      "url": "https://www.athome.com/mr.-clean-angle-broom/123569083.html"
    },
    {
      "url": "https://www.athome.com/mr.-clean-flat-back-bucket/123571674.html"
    }
  ],
  "minPrice": 0,
  "maxPrice": 0,
  "minRating": 0,
  "onSaleOnly": false,
  "inStockOnly": false,
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped At Home 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": "byUrls",
    "searchQuery": "rug",
    "department": "furniture",
    "productUrls": [
        {
            "url": "https://www.athome.com/mr.-clean-angle-broom/123569083.html"
        },
        {
            "url": "https://www.athome.com/mr.-clean-flat-back-bucket/123571674.html"
        }
    ],
    "minPrice": 0,
    "maxPrice": 0,
    "minRating": 0,
    "onSaleOnly": false,
    "inStockOnly": false,
    "sortBy": "relevance",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/athome-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": "byUrls",
    "searchQuery": "rug",
    "department": "furniture",
    "productUrls": [
        { "url": "https://www.athome.com/mr.-clean-angle-broom/123569083.html" },
        { "url": "https://www.athome.com/mr.-clean-flat-back-bucket/123571674.html" },
    ],
    "minPrice": 0,
    "maxPrice": 0,
    "minRating": 0,
    "onSaleOnly": False,
    "inStockOnly": False,
    "sortBy": "relevance",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/athome-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": "byUrls",
  "searchQuery": "rug",
  "department": "furniture",
  "productUrls": [
    {
      "url": "https://www.athome.com/mr.-clean-angle-broom/123569083.html"
    },
    {
      "url": "https://www.athome.com/mr.-clean-flat-back-bucket/123571674.html"
    }
  ],
  "minPrice": 0,
  "maxPrice": 0,
  "minRating": 0,
  "onSaleOnly": false,
  "inStockOnly": false,
  "sortBy": "relevance",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/athome-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "At Home Scraper - Furniture, Decor & Rugs",
        "description": "Scrape At Home (athome.com), the US home-decor superstore. Search products by keyword, browse by department (Furniture, Rugs, Lighting, Outdoor, and more), or fetch by direct product URL. Get prices, sale status, images, dimensions, ratings, and full category breadcrumbs.",
        "version": "1.0",
        "x-build-id": "aznsivFYHnVmWdFwc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~athome-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-athome-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~athome-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-athome-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~athome-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-athome-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",
                            "byUrls"
                        ],
                        "type": "string",
                        "description": "What to fetch: keyword search across product titles, browse a department, or fetch specific products by URL.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword(s) to search for in product titles, e.g. 'rug', 'table lamp', 'throw pillow' (mode=search). Matches against the full product catalog.",
                        "default": "rug"
                    },
                    "department": {
                        "title": "Department",
                        "enum": [
                            "furniture",
                            "outdoor",
                            "rugs",
                            "wall-decor",
                            "home-decor",
                            "pillows",
                            "kitchen-dining",
                            "bed-bath",
                            "window",
                            "lighting",
                            "storage-organization",
                            "holiday"
                        ],
                        "type": "string",
                        "description": "Home-decor department to browse (mode=byCategory). Results are verified against each product's real category breadcrumb.",
                        "default": "furniture"
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=byUrls)",
                        "type": "array",
                        "description": "Direct athome.com product page URLs to fetch, e.g. https://www.athome.com/mr.-clean-angle-broom/123569083.html.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "athome.com product URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "minPrice": {
                        "title": "Minimum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only return products priced at or above this amount. 0 means no minimum. Applied client-side after fetch.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Only return products priced at or below this amount. 0 means no maximum. Applied client-side after fetch.",
                        "default": 0
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return products rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Products with no rating are excluded once this is set above 0.",
                        "default": 0
                    },
                    "color": {
                        "title": "Filter by color",
                        "type": "string",
                        "description": "Only return products whose color contains this text (case-insensitive), e.g. 'blue', 'ivory', 'black'. Only some athome.com products (e.g. pillows, throws) expose a color attribute -- products without one always pass this filter."
                    },
                    "material": {
                        "title": "Filter by material",
                        "type": "string",
                        "description": "Only return products whose material contains this text (case-insensitive), e.g. 'wood', 'metal', 'polyester', 'glass'. Most athome.com products expose a material attribute -- products without one always pass this filter."
                    },
                    "onSaleOnly": {
                        "title": "On sale only",
                        "type": "boolean",
                        "description": "Only return products currently marked with a sale price.",
                        "default": false
                    },
                    "inStockOnly": {
                        "title": "In stock only",
                        "type": "boolean",
                        "description": "Only return products currently in stock.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "rating-desc",
                            "popularity-desc",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to order results after fetching. athome.com's own search/browse pages aren't reachable server-side, so sorting is applied client-side across the fetched batch.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of products to return.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Product pages are reliably reachable without a proxy; this is used only as an automatic fallback if a fetch is transiently blocked.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
