# Iosys Japan Used Phone & Tablet — Price & Stock in One Call (`jpmarketdata/iosys-phone-market-checker`) Actor

Used iPhone, Android and iPad prices from Iosys Japan in one call: price quantiles per model, the median premium between condition grades (Unused / A / B / C), carrier/capacity mix, units in stock and the share of blacklisted or weak-battery stock. From $0.02, no subscription. イオシスの中古スマホ相場を1コールで。

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

## Pricing

from $20.00 / 1,000 model market summaries

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

## Iosys Japan Used Phone & Tablet — Price & Stock in One Call

**What does this handset actually go for in Japan right now, and what does one condition grade cost over the next?** One call per model answers both, plus how many physical units are actually behind those listings.

This Actor reads [Iosys](https://iosys.co.jp/) (イオシス — one of Japan's larger used smartphone / tablet retailers, buying and selling nationwide from a single online catalog) and returns **one compact market record per model**:

- **`priceJpy`** — min / 25th / median / 75th / max and the average of every matching listing (tax included, the only price Iosys shows)
- **`rankPremium`** — the **median price ratio between adjacent condition grades** (未使用品 → 中古A → 中古B → 中古C). This is the number you cannot get from any single page, and it is what a buy-back desk or an exporter prices against
- **`byRank`** — listings, units, share and median price per grade
- **`inventory`** — `listings` **and `unitsInStock`**: Iosys publishes 在庫数 per listing, so "12 listings" can mean 30 handsets. Very few used-goods sites expose this
- **`conditionFlags`** — the share of stock flagged **ネットワーク利用制限▲** (carrier blacklist risk, the Japanese 赤ロム予備軍) and **バッテリー80%未満** (degraded battery). Both are the discount drivers of the Japanese used-phone market
- **`byCarrier` / `byCapacity`** — SIM-free vs docomo / au / SoftBank / Rakuten / Wi-Fi-only, and the storage mix, each with its own median
- Optionally every matched listing (name, grade, price, units, carrier, capacity, release date, flags, URL)

There is **no other Iosys Actor on the Store**, and the general "used phone" scrapers return raw listings you then have to aggregate yourself. This one returns the statistics, at a flat price per model, in about 8 seconds.

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

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

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

A default run (1 model, summary only) costs **$0.02** and takes about 8 seconds. **A model that matched nothing is never charged.**

### Input

| Field | Example | Notes |
|---|---|---|
| `models` | `["iPhone 14 Pro 256GB"]` | Model keywords as you would type them into the store. Spacing and full-width characters are normalized for you. Each model costs $0.02 |
| `strictNameFilter` | `true` | On by default — see below. Turn off to use the store's own (loose) result set |
| `maxPagesPerModel` | `5` | 24 listings per page. 5 pages = 120 listings, which is the entire result set for nearly every single model |
| `includeIndividualListings` | `false` | Enable to also get each matched listing as a record |
| `convertToUsd` | `true` | Adds USD stats at the current exchange rate |

### Why the strict name filter exists (and why it is on)

Iosys' own search is loose. Measured on 2026-07-26, `iPhone14 Pro 256GB` returned **27 hits — of which only 15 are actually a 14 Pro**; the other 12 are plain iPhone14 and iPhone14 Plus bodies. Averaging all 27 gives a median of ¥84,800 for a phone whose real median is ¥92,800.

So every word of your query is additionally required to appear in the product name, on a **word boundary** — which is what keeps the token `Pro` from matching `(PRODUCT)RED`, the colour name on nearly half of Apple's catalog, and the token `V` from matching `Xperia1 VIII`.

Both counts are always reported, so you can see how loose the store's search was:

| Field | Meaning |
|---|---|
| `totalMatchedRaw` | What Iosys' own search returned |
| `totalMatchedStrict` | How many of the fetched listings really are that model |
| `inventory.listings` | What the statistics were computed over (= strict, unless you turned the filter off) |

Accessories (cases, chargers, screen protectors — Iosys' `smartphonegoods` category) are **always** excluded, filter on or off: a `iPad Air4` search puts a ¥1,280 screen protector on top of the price-ascending list, and letting it in would halve the reported median.

Query spelling is normalized to match the store's own: `iPhone 14 Pro` → `iPhone14 Pro`, `Xperia 1 V` → `Xperia1 V`, `iPhone SE` → `iPhoneSE`. A number followed by a unit keeps its space (`iPad Air 11インチ`, `256GB`).

### Exact vs spread sample — always labelled

Every record carries **`priceBasis`**:

| `priceBasis` | What it means |
|---|---|
| **`exact`** | Every page of the result set was read, so the statistics cover the whole population. This is the normal case for a specific model |
| **`spread_sample`** | The result set is larger than `maxPagesPerModel`. The pages that were read are **spread evenly across the price range** rather than taken from the cheap end — the store is sorted cheapest-first, so reading pages 1..5 of a 13-page result would describe the cheapest 38 % of the market and understate the median. `pagesSampled` lists exactly which pages were used |

If a multi-model run hits the 95-second budget, the affected record also carries `truncatedForTimeLimit: true`.

### Output example (`type: "model_summary"`, values measured 2026-07-26)

```json
{
  "type": "model_summary",
  "query": "iPhone 14 Pro 256GB",
  "normalizedQuery": "iPhone14 Pro 256GB",
  "strictNameFilter": true,
  "totalMatchedRaw": 27,
  "totalMatchedStrict": 15,
  "listingsFetched": 27,
  "pagesFetched": 2,
  "pagesSampled": [1, 2],
  "priceBasis": "exact",
  "inventory": {"listings": 15, "unitsInStock": 17},
  "priceJpy": {"min": 77800, "p25": 90300, "median": 92800, "p75": 92800, "max": 109800, "average": 92667},
  "byRank": [
    {"rank": "中古Bランク", "listings": 13, "units": 15, "sharePct": 86.7, "medianJpy": 92800, "rankEn": "Used B"},
    {"rank": "中古Cランク", "listings": 2, "units": 2, "sharePct": 13.3, "medianJpy": 84800, "rankEn": "Used C"}
  ],
  "rankPremium": [
    {"betterRank": "中古Bランク", "worseRank": "中古Cランク", "betterMedianJpy": 92800,
     "worseMedianJpy": 84800, "medianRatio": 1.094, "premiumPct": 9.4}
  ],
  "byCarrier": [
    {"carrier": "SoftBank", "listings": 5, "units": 5, "sharePct": 33.3, "medianJpy": 92800},
    {"carrier": "SIM-free", "listings": 4, "units": 5, "sharePct": 26.7, "medianJpy": 88800},
    {"carrier": "au", "listings": 3, "units": 3, "sharePct": 20.0, "medianJpy": 92800},
    {"carrier": "docomo", "listings": 2, "units": 3, "sharePct": 13.3, "medianJpy": 92800},
    {"carrier": "Rakuten", "listings": 1, "units": 1, "sharePct": 6.7, "medianJpy": 87800}
  ],
  "byCapacity": [{"capacity": "256GB", "listings": 15, "units": 17, "sharePct": 100.0, "medianJpy": 92800}],
  "conditionFlags": {
    "networkRestrictionTriangle": {"count": 1, "sharePct": 6.7},
    "batteryUnder80": {"count": 1, "sharePct": 6.7}
  },
  "checkedAt": "2026-07-26T06:20:32+00:00",
  "sourceUrl": "https://iosys.co.jp/items?q=iPhone14+Pro+256GB&sort=l&page=1"
}
````

With `includeIndividualListings: true` you additionally get one record per matched listing:

```json
{
  "type": "listing",
  "model": "iPhone 14 Pro 256GB",
  "id": "390409",
  "name": "【ネットワーク利用制限▲】iPhone14 Pro A2889 (MQ0Q3J/A) 256GB スペースブラック 【Rakuten版SIMフリー】",
  "rank": "中古Bランク",
  "rankEn": "Used B",
  "priceJpy": 87800,
  "unitsInStock": 1,
  "carrier": "Rakuten",
  "capacity": "256GB",
  "releaseDate": "2022年9月",
  "networkRestriction": "▲",
  "batteryUnder80": false,
  "url": "https://iosys.co.jp/items/smartphone/iphone/rakuten/iphone14_pro_a2889/390409"
}
```

### Use cases

- **Export sourcing** — the Japanese used-iPhone market is a supply pool for the rest of Asia. `priceJpy` plus `byCarrier` tells you what an unlocked unit costs versus a carrier one, `unitsInStock` tells you whether the volume is there
- **Buy-back / trade-in pricing** — `rankPremium` is the empirical answer to "what is grade A worth over grade B this week" per model, instead of a fixed internal table
- **Risk-adjusted valuation** — `conditionFlags` quantifies how much of the supply carries a blacklist marker (▲) or a weak battery, the two flags that move Japanese used-phone prices most
- **Repricing & monitoring** — schedule the Actor over your model list and track the median and the grade premiums over time
- **Market entry research** — carrier and capacity mix per model, straight from live inventory

### Notes & limits

- Iosys is a **fixed-price retailer**, not a marketplace: prices are current asks, tax included. There is no sale date and no sold history, so no transaction time series
- **The buy-back side (k-tai-iosys.com) is not covered** — it is `Crawl-delay: 60` and JavaScript-rendered, so the sell/buy spread is not obtainable. This Actor is the selling side only
- The store's search is loose; see the strict-filter section. `totalMatchedRaw` is deliberately reported so the looseness is visible
- **Grade order is Iosys' own** (新品 > 未使用品 > アウトレット > 中古A > 中古B > 中古C). `rankPremium` compares grades that are adjacent **among those present** in the result set, so a model stocked only in A and C still gets one honest A-over-C figure
- A grade with a *lower* median than the grade below it is possible and is reported as a negative `premiumPct` — usually it means the query is broad enough to mix models. Tighten the query (add the capacity, add `Pro`) rather than distrusting the number
- Read-only and throttled (1 request / 1.5 s), 1–5 requests per model. Multi-model runs have a 95-second soft budget
- No personal data is collected — Iosys is a first-party retailer, there are no individual sellers

***

### 日本語ガイド

**イオシスの中古スマホ・タブレット相場を、機種1件につき1レコードで返す Actor です。**

- **概要**: 機種キーワードごとに **価格の分位点(最安・25%・中央値・75%・最高値・平均)** に加え、**ランク間プレミアム**(未使用品 → 中古A → 中古B → 中古C の隣接ランク中央値比)、**在庫の実数**(イオシスは商品ごとに「在庫数」を公開しているため、出品件数と実在庫台数を分けて返せます)、**ネットワーク利用制限▲(赤ロム予備軍)とバッテリー80%未満の構成比**、キャリア別・容量別の内訳を返します。輸出・買取の値付けに直結する数字を1コールで揃えるのが狙いです。
- **使い方**: `models` に機種キーワードを入れます(例 `iPhone 14 Pro 256GB` / `iPad Air4` / `Xperia 1 V`)。全角・スペースは自動で正規化され、`iPhone 14` は店舗の表記に合わせて `iPhone14` に直されます。個別明細が必要なときだけ `includeIndividualListings` を ON にしてください。
- **料金**: 機種サマリー1件 **$0.02**、個別リスティングは **$0.002/件**(既定 OFF なので既定実行は $0.02 固定)。**該当0件の機種には課金されません。** サブスクリプション不要です。
- **厳密フィルタ(既定 ON)**: イオシスの検索は緩く、実測(2026-07-26)では `iPhone14 Pro 256GB` の27件中**実際に 14 Pro なのは15件**で、残りは無印 iPhone14 / 14 Plus でした。そのまま集計すると中央値が ¥92,800 → ¥84,800 にずれます。そこで**クエリの全単語が商品名に含まれること**を追加条件にしています(単語境界で判定するため `Pro` が `(PRODUCT)RED` に、`V` が `Xperia1 VIII` に誤マッチしません)。`totalMatchedRaw`(店の検索結果)と `totalMatchedStrict`(実際に一致した件数)の両方を返すので、検索の緩さもそのまま見えます。ケース・フィルム等のアクセサリ(`smartphonegoods` カテゴリ)はフィルタの ON/OFF に関わらず常に除外します。
- **数値の根拠は必ず明示**: `priceBasis` が `exact`(結果全ページを取得=母集団の統計)か `spread_sample`(`maxPagesPerModel` を超える件数のため、**価格帯全体に等間隔でページを散らして**サンプリング)かを示します。イオシスは価格の安い順ソートなので、先頭から数ページだけ読むと安値側に偏る — それを避けるための設計で、実際に読んだページ番号は `pagesSampled` に入ります。
- **その他**: イオシスは定価販売の中古小売で、価格は「現在の販売価格(税込)」です。成約履歴・販売日は取得できません。**買取側(k-tai-iosys.com)は robots の `Crawl-delay: 60` と JS 描画のため対象外**で、販売/買取スプレッドは取得できません。ランク中央値が下位ランクを下回る(`premiumPct` が負)場合は、クエリが広すぎて別機種が混ざっているサインです — 容量や `Pro` を足して絞り込んでください。

# Actor input Schema

## `models` (type: `array`):

One or more model keywords, written the way you would type them into the store's search box (iPhone 14 Pro 256GB, iPhone SE 第3世代, iPad Air4, Xperia 1 V, Pixel 8). Spacing and full-width characters are normalized automatically ('iPhone 14' becomes 'iPhone14', which is how Iosys writes it). Each model costs $0.02.

## `strictNameFilter` (type: `boolean`):

On by default. Iosys' own search is loose — a query for 'iPhone14 Pro' also returns plain iPhone14 bodies — so every word of your query is additionally required to appear in the product name before a listing enters the statistics. Turn it off to get the store's raw result set (useful for a broad keyword such as a brand name). Accessories (cases, chargers, screen protectors) are always excluded, filter on or off.

## `maxPagesPerModel` (type: `integer`):

Results come 24 per page. If a model has more pages than this, the pages that are read are spread evenly across the price range (the store is sorted cheapest-first, so reading only the first pages would understate the market) and the summary is labelled priceBasis: 'spread\_sample'. 5 pages cover up to 120 listings, which is the whole result set for almost every single model.

## `includeIndividualListings` (type: `boolean`):

Off by default: a run costs a flat $0.02 per model summary. Enable to also get every matched listing (name, condition grade, price, units in stock, carrier, capacity, release date, network-restriction marker, battery flag, 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
{
  "models": [
    "iPhone 14 Pro 256GB"
  ],
  "strictNameFilter": true,
  "maxPagesPerModel": 5,
  "includeIndividualListings": 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 = {
    "models": [
        "iPhone 14 Pro 256GB"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/iosys-phone-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 = { "models": ["iPhone 14 Pro 256GB"] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/iosys-phone-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 '{
  "models": [
    "iPhone 14 Pro 256GB"
  ]
}' |
apify call jpmarketdata/iosys-phone-market-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Iosys Japan Used Phone & Tablet — Price & Stock in One Call",
        "description": "Used iPhone, Android and iPad prices from Iosys Japan in one call: price quantiles per model, the median premium between condition grades (Unused / A / B / C), carrier/capacity mix, units in stock and the share of blacklisted or weak-battery stock. From $0.02, no subscription. イオシスの中古スマホ相場を1コールで。",
        "version": "0.1",
        "x-build-id": "GzytcfVWgfkXc1RCD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jpmarketdata~iosys-phone-market-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jpmarketdata-iosys-phone-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~iosys-phone-market-checker/runs": {
            "post": {
                "operationId": "runs-sync-jpmarketdata-iosys-phone-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~iosys-phone-market-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jpmarketdata-iosys-phone-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": [
                    "models"
                ],
                "properties": {
                    "models": {
                        "title": "Models",
                        "type": "array",
                        "description": "One or more model keywords, written the way you would type them into the store's search box (iPhone 14 Pro 256GB, iPhone SE 第3世代, iPad Air4, Xperia 1 V, Pixel 8). Spacing and full-width characters are normalized automatically ('iPhone 14' becomes 'iPhone14', which is how Iosys writes it). Each model costs $0.02.",
                        "default": [
                            "iPhone 14 Pro 256GB"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "strictNameFilter": {
                        "title": "Strict model-name filter",
                        "type": "boolean",
                        "description": "On by default. Iosys' own search is loose — a query for 'iPhone14 Pro' also returns plain iPhone14 bodies — so every word of your query is additionally required to appear in the product name before a listing enters the statistics. Turn it off to get the store's raw result set (useful for a broad keyword such as a brand name). Accessories (cases, chargers, screen protectors) are always excluded, filter on or off.",
                        "default": true
                    },
                    "maxPagesPerModel": {
                        "title": "Max pages per model",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Results come 24 per page. If a model has more pages than this, the pages that are read are spread evenly across the price range (the store is sorted cheapest-first, so reading only the first pages would understate the market) and the summary is labelled priceBasis: 'spread_sample'. 5 pages cover up to 120 listings, which is the whole result set for almost every single model.",
                        "default": 5
                    },
                    "includeIndividualListings": {
                        "title": "Include individual listings",
                        "type": "boolean",
                        "description": "Off by default: a run costs a flat $0.02 per model summary. Enable to also get every matched listing (name, condition grade, price, units in stock, carrier, capacity, release date, network-restriction marker, battery flag, 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
