# WooCommerce Product Scraper (`khadinakbar/woocommerce-product-scraper`) Actor

Scrape public WooCommerce product catalogs for price, stock, rating, and category monitoring. Use for competitor or supplier research, not private data. Returns normalized product rows with price, availability, reviews, and source provenance. $0.004/product plus a $0.00005 start fee; usage extra.

- **URL**: https://apify.com/khadinakbar/woocommerce-product-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (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 $4.00 / 1,000 product returneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## WooCommerce Product Scraper

Extract public, published product catalog data from WooCommerce stores through its Store API. Each dataset row is a normalized product record with price, stock, rating, categories, images, and source-endpoint provenance.

Use it for competitor price tracking, supplier catalog research, and e-commerce assortment analysis. Do not use it for orders, customers, checkout details, unpublished products, or a store whose public Store API is disabled.

### Output

One validated dataset item per public product. The output stays compact enough for agent use; store-level diagnostics are written separately to `OUTPUT` and `RUN_SUMMARY`.

| Field | Description |
| --- | --- |
| `productId`, `title`, `productUrl` | Stable public product identifiers and canonical URL |
| `price`, `regularPrice`, `salePrice`, `currency` | API prices normalized from WooCommerce minor units |
| `stockStatus`, `inStock`, `onBackorder`, `lowStockRemaining` | Published availability signals |
| `averageRating`, `reviewCount` | Public review signals |
| `categories`, `tags`, `attributes`, `variationsCount` | Product taxonomy and option metadata |
| `imageUrl`, `imageUrls` | Primary image plus up to ten public image URLs |
| `storeUrl`, `storeDomain`, `sourceEndpoint`, `scrapedAt` | Provenance and freshness fields |

### Pricing

| Event | Price |
| --- | ---: |
| Valid actor start | $0.00005 / run |
| Validated product returned | $0.004 / product |

A default 100-product run is capped at **$0.40005 in event charges**, plus Apify platform usage. Products that fail validation, blocked stores, invalid inputs, and empty stores are never billed as returned products. The deployed actor will use **Pay per event + usage**, so proxy and compute usage are shown separately by Apify.

### Input

`storeUrls` is the only required input. Provide a store homepage or a WooCommerce installation in a subdirectory.

```json
{
  "storeUrls": ["https://porterandyork.com"],
  "maxProducts": 100,
  "search": "steak",
  "stockStatuses": ["instock"],
  "onSale": false,
  "sortBy": "price",
  "sortOrder": "asc"
}
````

| Field | Use it for |
| --- | --- |
| `storeUrls` | One to 100 public WooCommerce store URLs. This is not a product or admin URL. |
| `maxProducts` | One run-wide product cap, from 1 to 10,000. |
| `search` | Optional Store API product text search. Leave empty for the full catalog. |
| `categoryIds` | Optional public WooCommerce category IDs, for example `[12, 27]`. |
| `stockStatuses` | Optional `instock`, `outofstock`, and/or `onbackorder` filter. |
| `onSale`, `featured` | Set to `true` only to filter to those products. `false` does not add a filter. |
| `sortBy`, `sortOrder` | Store API ordering: `date`, `price`, `popularity`, or `rating`; `asc` or `desc`. |
| `proxyConfiguration` | Optional Apify Proxy fallback for stores that block direct API requests. No cookies or credentials are accepted. |

### Example output

```json
{
  "productId": "42",
  "title": "Organic Espresso Blend",
  "productUrl": "https://example.com/product/organic-espresso-blend/",
  "storeDomain": "example.com",
  "sourceEndpoint": "https://example.com/wp-json/wc/store/v1/products?page=1&per_page=100",
  "currency": "USD",
  "price": 19.99,
  "regularPrice": 24.99,
  "salePrice": 19.99,
  "onSale": true,
  "stockStatus": "instock",
  "averageRating": 4.75,
  "reviewCount": 12,
  "categories": ["Coffee"],
  "attributes": [{ "name": "Grind", "values": ["Whole bean", "Ground"] }],
  "scrapedAt": "2026-07-14T12:00:00.000Z"
}
```

### How it works

For each store, the actor requests the unauthenticated public endpoint:

```text
GET /wp-json/wc/store/v1/products?page=1&per_page=100
```

It applies supported Store API filters, follows pagination, normalizes the public response, validates the complete product contract, then writes and bills the row together through the Apify SDK. It retries temporary `429` and `5xx` responses with bounded backoff; `401`, `403`, and `404` responses are not retried indefinitely.

The actor never tries the authenticated WooCommerce admin REST API. It therefore cannot return private products, exact inventory records hidden by a store, customer data, orders, or content that the Store API does not expose.

### Results and failure semantics

Every terminal path writes two key-value records:

| Key | Purpose |
| --- | --- |
| `OUTPUT` | Compact outcome, result count, warnings, and charged-event count |
| `RUN_SUMMARY` | Detailed store diagnostics, coverage, errors, and charge-cap state |

The actor uses these outcomes truthfully:

- `COMPLETE` — all requested stores produced the advertised data.
- `PARTIAL` — useful products were returned, but a store failed or a cap/deadline stopped additional work.
- `VALID_EMPTY` — functioning Store API responses had no products matching the filters.
- `INVALID_INPUT` — correct the request; no Store API requests or result charges were made.
- `UPSTREAM_FAILED` — valid input could not obtain any usable Store API product response.

Dataset rows never contain synthetic error records. This keeps CSV, JSON, and MCP consumers from mistaking a diagnostic for a product.

### API and AI-agent use

This is a regular Apify Actor and can be called through the Apify API, schedules, integrations, or the Apify MCP server after deployment. It is a good fit for an agent that needs structured public WooCommerce catalog data from a known store URL; it is not a substitute for a general website crawler or a WooCommerce administration API.

For a small, predictable call, keep `maxProducts` at 100 or below. Inspect `OUTPUT` before treating a partial run as a full catalog export.

### Limitations

- Only published products returned by the target's public WooCommerce Store API are in scope.
- Stores can disable, restrict, rate-limit, or geo-block the API; enable Apify Proxy only when needed.
- WooCommerce extensions can add or remove fields. The actor skips malformed rows rather than fabricating incomplete billable data.
- Product variations are represented by a count and public attributes, not separate variation rows.
- Product descriptions are converted to plain text and bounded to keep records agent-friendly.

### Legal and responsible use

This actor collects only publicly accessible product catalog data. You are responsible for complying with each target's terms, robots directives, applicable law, copyright, database rights, and privacy obligations. Do not use it to access private, authenticated, or personal data.

# Actor input Schema

## `storeUrls` (type: `array`):

Use this when you need a public WooCommerce store catalog, such as 'https://porterandyork.com'. Add a homepage URL or a store installed in a subdirectory, and the actor calls its public Store API. The actor extracts published product data only and accepts up to 100 stores. Do not use product, order, customer, checkout, or WordPress admin URLs here.

## `maxProducts` (type: `integer`):

Use this to set one hard product cap across every requested store, such as 100. It accepts whole numbers from 1 through 10,000 and defaults to 100. Billing and Store API pagination stop after this many validated product rows. It is not a per-store cap and does not count pages, categories, or variants separately.

## `search` (type: `string`):

Use this to ask the WooCommerce Store API for products matching a text phrase, such as 'organic coffee'. It accepts up to 200 characters and is empty by default, which returns the full catalog. Store search behavior is supplied by each target store and may not match its storefront search exactly. It is not a Google query or a product URL.

## `categoryIds` (type: `array`):

Use this to limit output to public WooCommerce category IDs, for example \[12, 27]. It accepts positive numeric IDs and defaults to an empty list, which applies no category filter. IDs are store-specific, so obtain them from the store's public Store API or product data first. This is not a list of category names or URL slugs.

## `stockStatuses` (type: `array`):

Use this to return products in one or more public stock states, such as 'instock'. It accepts instock, outofstock, and onbackorder and defaults to an empty list, which applies no stock filter. Multiple values are sent to the official Store API as an array filter. It is not an exact inventory-count filter.

## `onSale` (type: `boolean`):

Use this when you need only products that the public Store API marks as on sale. Set true to apply the filter; false is the default and leaves the catalog unfiltered by sale status. The value is sent directly to the Store API rather than inferred from price comparisons. It does not guarantee that a store's promotion has a regular-price field.

## `featured` (type: `boolean`):

Use this when you need only catalog items that WooCommerce marks as featured. Set true to apply the filter; false is the default and leaves the catalog unfiltered by featured status. The flag is read from the public Store API and can differ from a theme's visual merchandising. It is not a filter for best-selling or newest products.

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

Use this to choose the Store API sorting field, for example price. It accepts date, price, popularity, or rating and defaults to date. Set sortOrder separately to choose ascending or descending results. It does not sort output after retrieval or bypass the maximum product cap.

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

Use this to choose ascending or descending order for the selected Store API sort field. It accepts asc or desc and defaults to desc. The setting applies to the target API before pagination begins. It is not a way to order multiple stores relative to each other.

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

Use this only if a public Store API blocks the default direct request path. Set useApifyProxy to true and optionally choose a proxy group or two-letter country code. It defaults to direct HTTP requests because the public WooCommerce Store API is usually accessible without a proxy. This setting never accepts third-party credentials, cookies, or authorization tokens.

## Actor input object example

```json
{
  "storeUrls": [
    "https://porterandyork.com",
    "https://example.com/shop"
  ],
  "maxProducts": 100,
  "search": "organic coffee",
  "categoryIds": [
    12,
    27
  ],
  "stockStatuses": [
    "instock"
  ],
  "onSale": true,
  "featured": true,
  "sortBy": "price",
  "sortOrder": "asc",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Normalized WooCommerce product rows from the public Store API.

## `output` (type: `string`):

Compact terminal outcome and product-count contract.

## `runSummary` (type: `string`):

Detailed per-store diagnostic and charge summary.

# 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 = {
    "storeUrls": [
        "https://porterandyork.com"
    ],
    "maxProducts": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/woocommerce-product-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 = {
    "storeUrls": ["https://porterandyork.com"],
    "maxProducts": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/woocommerce-product-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 '{
  "storeUrls": [
    "https://porterandyork.com"
  ],
  "maxProducts": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call khadinakbar/woocommerce-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WooCommerce Product Scraper",
        "description": "Scrape public WooCommerce product catalogs for price, stock, rating, and category monitoring. Use for competitor or supplier research, not private data. Returns normalized product rows with price, availability, reviews, and source provenance. $0.004/product plus a $0.00005 start fee; usage extra.",
        "version": "0.1",
        "x-build-id": "PCBm6ERQDtxdqa1d1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~woocommerce-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-woocommerce-product-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/khadinakbar~woocommerce-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-woocommerce-product-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/khadinakbar~woocommerce-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-woocommerce-product-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": [
                    "storeUrls"
                ],
                "properties": {
                    "storeUrls": {
                        "title": "WooCommerce store URLs",
                        "type": "array",
                        "description": "Use this when you need a public WooCommerce store catalog, such as 'https://porterandyork.com'. Add a homepage URL or a store installed in a subdirectory, and the actor calls its public Store API. The actor extracts published product data only and accepts up to 100 stores. Do not use product, order, customer, checkout, or WordPress admin URLs here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Maximum products per run",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Use this to set one hard product cap across every requested store, such as 100. It accepts whole numbers from 1 through 10,000 and defaults to 100. Billing and Store API pagination stop after this many validated product rows. It is not a per-store cap and does not count pages, categories, or variants separately.",
                        "default": 100
                    },
                    "search": {
                        "title": "Product search query",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Use this to ask the WooCommerce Store API for products matching a text phrase, such as 'organic coffee'. It accepts up to 200 characters and is empty by default, which returns the full catalog. Store search behavior is supplied by each target store and may not match its storefront search exactly. It is not a Google query or a product URL.",
                        "default": ""
                    },
                    "categoryIds": {
                        "title": "WooCommerce category IDs",
                        "type": "array",
                        "description": "Use this to limit output to public WooCommerce category IDs, for example [12, 27]. It accepts positive numeric IDs and defaults to an empty list, which applies no category filter. IDs are store-specific, so obtain them from the store's public Store API or product data first. This is not a list of category names or URL slugs.",
                        "items": {
                            "type": "integer",
                            "minimum": 1
                        },
                        "default": []
                    },
                    "stockStatuses": {
                        "title": "Stock-status filter",
                        "type": "array",
                        "description": "Use this to return products in one or more public stock states, such as 'instock'. It accepts instock, outofstock, and onbackorder and defaults to an empty list, which applies no stock filter. Multiple values are sent to the official Store API as an array filter. It is not an exact inventory-count filter.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "instock",
                                "outofstock",
                                "onbackorder"
                            ]
                        },
                        "default": []
                    },
                    "onSale": {
                        "title": "Only products on sale",
                        "type": "boolean",
                        "description": "Use this when you need only products that the public Store API marks as on sale. Set true to apply the filter; false is the default and leaves the catalog unfiltered by sale status. The value is sent directly to the Store API rather than inferred from price comparisons. It does not guarantee that a store's promotion has a regular-price field.",
                        "default": false
                    },
                    "featured": {
                        "title": "Only featured products",
                        "type": "boolean",
                        "description": "Use this when you need only catalog items that WooCommerce marks as featured. Set true to apply the filter; false is the default and leaves the catalog unfiltered by featured status. The flag is read from the public Store API and can differ from a theme's visual merchandising. It is not a filter for best-selling or newest products.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort products by",
                        "enum": [
                            "date",
                            "price",
                            "popularity",
                            "rating"
                        ],
                        "type": "string",
                        "description": "Use this to choose the Store API sorting field, for example price. It accepts date, price, popularity, or rating and defaults to date. Set sortOrder separately to choose ascending or descending results. It does not sort output after retrieval or bypass the maximum product cap.",
                        "default": "date"
                    },
                    "sortOrder": {
                        "title": "Sort direction",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Use this to choose ascending or descending order for the selected Store API sort field. It accepts asc or desc and defaults to desc. The setting applies to the target API before pagination begins. It is not a way to order multiple stores relative to each other.",
                        "default": "desc"
                    },
                    "proxyConfiguration": {
                        "title": "Apify Proxy configuration",
                        "type": "object",
                        "description": "Use this only if a public Store API blocks the default direct request path. Set useApifyProxy to true and optionally choose a proxy group or two-letter country code. It defaults to direct HTTP requests because the public WooCommerce Store API is usually accessible without a proxy. This setting never accepts third-party credentials, cookies, or authorization tokens.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
