# BookOff Japan Used Media — Price & Stock Stats in One Call (`jpmarketdata/bookoff-market-checker`) Actor

Used-price stats for any keyword on BookOff's official Japanese online store, in one call: population quartiles (min/Q1/median/Q3/max) of the whole result set — not a first-page sample — plus stock split, out-of-stock share and discount vs list price. From $0.02, no subscription. ブックオフの中古相場を1コールで。

- **URL**: https://apify.com/jpmarketdata/bookoff-market-checker.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 keyword market analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## BookOff Japan Used Media — Price & Stock Stats in One Call

**What does a used copy of this actually sell for in Japan?** One call per keyword answers it with the **quartiles of the entire result set** — not the first page, not an average of whatever the site felt like showing first.

This Actor reads [BookOff's official online store](https://shopping.bookoff.co.jp/) (ブックオフ公式オンラインストア — Japan's largest secondhand chain for books, manga, CDs, DVDs and games, 800+ physical stores behind one catalog) and returns **one compact market record per keyword**:

- **`usedPriceJpy` — min / Q1 / median / Q3 / max of the whole population.** For a 4,893-hit keyword that is the real 25th/50th/75th percentile of all 4,893 listings, obtained in 5 requests, not an estimate from 120 samples
- **`outOfStockRatioSampled`** — BookOff keeps sold-out products listed **with their last price**, so the sold-out share is a turnover signal and the sold-out prices are the closest public thing to *sold comps* for Japanese used media
- **`stockBreakdown`** — in stock / low / last one / out of stock
- **`discountVsListPricePct`** — how far below the Japanese list price (定価) the used copies sit
- **`newPriceJpy`**, **`genreTop`**, plus USD conversion at the current rate
- Optionally every sampled listing (title, price, condition, stock, list price, discount, release date, store-pickup flag, URL)

Existing BookOff scrapers on the Store return **raw listing dumps**: you pay per record, then compute the statistics yourself. This one returns **the statistics**, at a flat price per keyword, in ~8 seconds.

No login, no API key, nothing stored between runs.

### Pricing — from $0.02 per keyword, no subscription

| Event | Price | When |
|---|---|---|
| Keyword market summary | **$0.02** | Per keyword analyzed |
| Individual listing | **$0.002** | Only if you enable **Include individual listings** |

A default run (1 keyword, summary only) costs **$0.02** and takes about 8 seconds. **A keyword that returns zero listings is never charged.**

### Input

| Field | Example | Notes |
|---|---|---|
| `keywords` | `["ガンダム"]` | Japanese works best — the catalog is Japanese-only. Each keyword costs $0.02 |
| `genreCode` | `"11"` | Optional: `12` Books / `11` Comics / `13` Magazines / `31` CD / `71` DVD & Blu-ray / `51` Games. Empty = all genres |
| `maxItemsPerKeyword` | `120` | Listings inspected for the stock / discount / genre mix (30–360, 120 per page). Does **not** affect the quartiles; below 120 it only caps how many individual listings are returned |
| `includeIndividualItems` | `false` | Enable to also get each sampled listing as a record |
| `convertToUsd` | `true` | Adds USD stats at the current exchange rate |

### Exact vs population quantiles vs sample — always labelled

Every record carries **`usedPriceJpyBasis`**, so you never have to guess how a number was produced:

| `usedPriceJpyBasis` | What it means | How it is obtained | When you get it |
|---|---|---|---|
| **`exact`** | True statistics over **every matching listing** | The whole result set fits on one page (≤120 hits), so all of it is read — 1 request | Narrow keywords |
| **`population_quantiles`** | min / Q1 / median / Q3 / max are **real population quantiles**, `count` = the full hit count | Listings are sorted by used price ascending and the Actor jumps straight to the page holding the rank of each quantile (e.g. hits 1,224 / 2,447 / 3,670 of 4,893 = pages 11 / 21 / 31), plus one descending page for the maximum — 5 requests | Most keywords |
| **`sample`** | Ordinary sample statistics over the listings that were inspected, `count` = sample size | Fallback. Used when the price order turns out **not** to be monotonic across pages, or when a multi-keyword run hits its time budget (then `truncatedForTimeLimit: true` is also set) | Rare |

The fallback is the point: if the store ever changes its sort behaviour, the Actor **stops claiming population quantiles** instead of quietly returning wrong percentiles.

`newPriceJpy`, `stockBreakdown`, `outOfStockRatioSampled`, `discountVsListPricePct` and `genreTop` are **always sample-based** (`sampledListings` tells you the size). With the default `maxItemsPerKeyword: 120` the sample is the 120 cheapest listings, so read the stock split as "the low-price end of this market"; raise it to 240/360 and the sample is automatically spread across the price range using the quantile pages that are fetched anyway — **no extra requests, no extra time.**

### Output example (`type: "market_summary"`, values measured for ガンダム)

```json
{
  "type": "market_summary",
  "keyword": "ガンダム",
  "genre": null,
  "genreName": null,
  "totalListingsFound": 4893,
  "sampledListings": 120,
  "usedPriceJpy": {"min": 99, "q1": 330, "median": 550, "q3": 1375, "max": 77000, "count": 4893},
  "usedPriceJpyBasis": "population_quantiles",
  "newPriceJpy": {"min": 528, "q1": 660, "median": 990, "q3": 1650, "max": 6600, "count": 14},
  "stockBreakdown": {"inStock": 12, "lowStock": 6, "lastOne": 4, "outOfStock": 98},
  "outOfStockRatioSampled": 0.8167,
  "discountVsListPricePct": {"median": 78},
  "genreTop": [["コミック", 61], ["書籍", 34], ["DVD・ブルーレイ", 12]],
  "usedPriceUsd": {"min": 0.63, "q1": 2.11, "median": 3.52, "q3": 8.8, "max": 492.8},
  "exchangeRateJpyUsd": 0.0064,
  "checkedAt": "2026-07-25T09:00:00+00:00",
  "sourceUrl": "https://shopping.bookoff.co.jp/search/keyword/%E3%82%AC%E3%83%B3%E3%83%80%E3%83%A0?per-page=120&sort=50&p=1"
}
````

With `includeIndividualItems: true` you additionally get one record per listing:

```json
{
  "type": "item",
  "keyword": "ガンダム",
  "id": "0016400324",
  "title": "閉ざされた世界 THE BACK HORN,THE BACK HORN",
  "priceJpy": 99,
  "condition": "used",
  "stockStatus": "last_one",
  "listPriceJpy": 1257,
  "discountPct": 92,
  "releaseDate": "2010/08/04",
  "storePickup": true,
  "url": "https://shopping.bookoff.co.jp/used/0016400324"
}
```

### Use cases

- **Import & resale sourcing** — check the Japanese used price band for a title before buying through a proxy service, and compare it against eBay/Mercari sold prices
- **Pricing your own inventory** — the median and Q3 of the *whole* result set are what the Japanese market actually charges, not what the loudest listing asks
- **Turnover screening** — a high `outOfStockRatioSampled` with a thin in-stock count means the title moves; a low one means it sits on shelves
- **Catalog / rights research** — how deep is the secondhand supply of a series, a label or an artist, and at what discount to list price
- **Repricing & monitoring** — schedule the Actor and track the median per keyword over time

### Notes & limits

- **Trading cards, figures and hobby goods are out of scope.** BookOff's official online store has no TCG / hobby genre — only books, comics, magazines, CDs, DVDs & Blu-ray and games. Use a Mandarake or Suruga-ya source for cards and figures
- Keywords are matched against a **Japanese** catalog; English keywords mostly do not match. Use 日本語 (ガンダム, 鬼滅の刃, 米津玄師)
- BookOff is a fixed-price retailer, not a marketplace: prices are **asks**, and a sold-out product's price is the **last price it was offered at** — a good pseudo sold comp, but it is a product-master price, not a record of individual transactions, and it carries no sale date (so no time series)
- The store's default order is 人気順 (popularity), which is best-seller/ad weighted. This Actor **always sends an explicit sort** so the statistics are not skewed
- `totalListingsFound` counts every matching listing, in stock or not
- "In stock only" / "used only" filters exist in the site's UI but their query parameters are not publicly stable, so v1 reports the stock split from the sample instead of filtering server-side
- Read-only and throttled (1 request / 1.5 s), 5 requests per keyword. Multi-keyword runs have a 95-second soft budget: keywords beyond it still return a summary, marked `truncatedForTimeLimit` with `usedPriceJpyBasis: "sample"`
- No personal data is collected — BookOff is a first-party retailer, there are no sellers

***

### 日本語ガイド

**ブックオフ公式オンラインストアの中古相場を、キーワード1件につき1レコードで返す Actor です。**

- **概要**: キーワードごとに **中古価格の分位点(最安・Q1・中央値・Q3・最高値)** を返します。特徴は、先頭ページのサンプル統計ではなく **検索結果の母集団そのものの分位点** を返せること — 中古価格の安い順に並べ替え、各分位点の順位が載っているページへ直接ジャンプして読み取ります(例: 全4,893件なら 11 / 21 / 31 ページ目、計5リクエスト)。あわせて在庫内訳(在庫あり/残りわずか/残り1点/在庫なし)、**在庫なし比率**(ブックオフは売り切れ商品も価格付きで残るため、回転率と「実売価格に近い値」の指標になります)、定価に対する割引率の中央値、新品価格、ジャンル内訳、USD換算を返します。
- **使い方**: `keywords` に**日本語**のキーワードを入れてください(カタログが日本語のため)。`genreCode` でジャンルを絞れます(12=書籍 / 11=コミック / 13=雑誌 / 31=CD / 71=DVD・ブルーレイ / 51=ゲーム)。個別商品の明細が必要なときだけ `includeIndividualItems` を ON にします。
- **料金**: キーワードサマリー1件 **$0.02**、個別商品レコードは **$0.002/件**(既定 OFF なので既定実行は $0.02 固定)。**0件のキーワードには課金されません。** サブスクリプション不要です。
- **数値の根拠は必ず明示**: `usedPriceJpyBasis` が `exact`(全件が1ページに収まり全数集計)/ `population_quantiles`(母集団分位点)/ `sample`(サンプル統計)のどれかを示します。ページ間で価格順が単調でない場合や、複数キーワードで時間予算(95秒)を超えた場合は**母集団分位点を名乗らず** `sample` に落ちます(誤った数値を黙って出さないため)。在庫内訳・割引率・ジャンル内訳・新品価格は常にサンプル基準です。
- **対象外**: **トレカ・ホビー・フィギュア系のジャンルは公式オンラインストアに存在しないため対象外です**(書籍・コミック・雑誌・CD・DVD・ゲームのみ)。トレカやフィギュアの相場はまんだらけ等のソースをご利用ください。
- **その他**: ブックオフは定価販売の中古小売であり、価格は「出品価格」です。売り切れ商品の価格は「最後に提示されていた価格」であって個々の成約記録ではなく、販売日時も取得できません(時系列分析は不可)。既定の並び順(人気順)は広告・売れ筋バイアスがあるため、本 Actor は常にソートを明示して取得します。

# Actor input Schema

## `keywords` (type: `array`):

One or more search keywords. Japanese works best — BookOff's catalog is Japanese-only (ガンダム, ワンピース, ドラゴンクエスト, 米津玄師). Each keyword costs $0.02.

## `genreCode` (type: `string`):

Restrict the search to one BookOff genre: 12=Books (書籍), 11=Comics (コミック), 13=Magazines (雑誌), 31=CD, 71=DVD & Blu-ray, 51=Games (ゲーム). Leave empty to search all genres. Note: trading cards and hobby/figure genres do not exist on the official online store.

## `maxItemsPerKeyword` (type: `integer`):

How many listings to inspect per keyword for the stock split, discount and genre mix. The used-price quartiles are read from the whole result set and are not affected. Results come 120 per page, so values above 120 add the quantile pages that are fetched anyway — the sample spreads across the price range at no extra request and no extra time — while values below 120 only limit how many individual listings are returned (and billed) when 'Include individual listings' is on (+$0.002 per listing).

## `includeIndividualItems` (type: `boolean`):

Off by default: a run costs a flat $0.02 per keyword summary. Enable to also get every sampled listing (title, price, condition, stock status, list price, discount, release date, store pickup, URL) at +$0.002 per listing.

## `convertToUsd` (type: `boolean`):

Adds USD statistics next to JPY using the current exchange rate (open.er-api.com).

## Actor input object example

```json
{
  "keywords": [
    "ガンダム"
  ],
  "maxItemsPerKeyword": 120,
  "includeIndividualItems": false,
  "convertToUsd": true
}
```

# 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 = {
    "keywords": [
        "ガンダム"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/bookoff-market-checker").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 = { "keywords": ["ガンダム"] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/bookoff-market-checker").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 '{
  "keywords": [
    "ガンダム"
  ]
}' |
apify call jpmarketdata/bookoff-market-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BookOff Japan Used Media — Price & Stock Stats in One Call",
        "description": "Used-price stats for any keyword on BookOff's official Japanese online store, in one call: population quartiles (min/Q1/median/Q3/max) of the whole result set — not a first-page sample — plus stock split, out-of-stock share and discount vs list price. From $0.02, no subscription. ブックオフの中古相場を1コールで。",
        "version": "0.1",
        "x-build-id": "VJ613yPdjCTGbAsGY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jpmarketdata~bookoff-market-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jpmarketdata-bookoff-market-checker",
                "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/jpmarketdata~bookoff-market-checker/runs": {
            "post": {
                "operationId": "runs-sync-jpmarketdata-bookoff-market-checker",
                "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/jpmarketdata~bookoff-market-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jpmarketdata-bookoff-market-checker",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "One or more search keywords. Japanese works best — BookOff's catalog is Japanese-only (ガンダム, ワンピース, ドラゴンクエスト, 米津玄師). Each keyword costs $0.02.",
                        "default": [
                            "ガンダム"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "genreCode": {
                        "title": "Genre code (optional)",
                        "type": "string",
                        "description": "Restrict the search to one BookOff genre: 12=Books (書籍), 11=Comics (コミック), 13=Magazines (雑誌), 31=CD, 71=DVD & Blu-ray, 51=Games (ゲーム). Leave empty to search all genres. Note: trading cards and hobby/figure genres do not exist on the official online store."
                    },
                    "maxItemsPerKeyword": {
                        "title": "Max listings sampled per keyword",
                        "minimum": 30,
                        "maximum": 360,
                        "type": "integer",
                        "description": "How many listings to inspect per keyword for the stock split, discount and genre mix. The used-price quartiles are read from the whole result set and are not affected. Results come 120 per page, so values above 120 add the quantile pages that are fetched anyway — the sample spreads across the price range at no extra request and no extra time — while values below 120 only limit how many individual listings are returned (and billed) when 'Include individual listings' is on (+$0.002 per listing).",
                        "default": 120
                    },
                    "includeIndividualItems": {
                        "title": "Include individual listings",
                        "type": "boolean",
                        "description": "Off by default: a run costs a flat $0.02 per keyword summary. Enable to also get every sampled listing (title, price, condition, stock status, list price, discount, release date, store pickup, URL) at +$0.002 per listing.",
                        "default": false
                    },
                    "convertToUsd": {
                        "title": "Convert prices to USD",
                        "type": "boolean",
                        "description": "Adds USD statistics next to JPY using the current exchange rate (open.er-api.com).",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
