# Stock Price Tracker — Real-Time Quotes (Stocks, Crypto, Forex) (`khadinakbar/stock-price-tracker`) Actor

Fetch real-time price quotes for stocks, ETFs, indices, crypto, forex, mutual funds, and futures from Yahoo Finance. Returns price, change, day range, volume, market cap, and 52-week range per ticker. Up to 500 symbols per run, sub-second per ticker, agent-friendly schema. $0.001/ticker.

- **URL**: https://apify.com/khadinakbar/stock-price-tracker.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Automation, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ticker price fetcheds

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

## Stock Price Tracker — Real-Time Quotes for Stocks, ETFs, Crypto, Forex & Indices

Fetch real-time price quotes for **stocks, ETFs, indices, crypto, forex, mutual funds, and futures** from Yahoo Finance in a single batched call. Built for AI portfolio agents, watchlist automations, trading bots, and high-volume price monitoring — sub-second per ticker, agent-friendly schema, **$0.001 per ticker resolved**.

### What you get

One row per ticker with the fields a tracking job actually needs — price, change, day range, volume, market cap, 52-week range — and **no junk** (no internal Yahoo IDs, no MIME blobs, no ten-level-deep nesting).

| Field | Type | Description |
|---|---|---|
| `ticker` | string | Resolved Yahoo symbol (e.g., `AAPL`, `BTC-USD`, `^GSPC`) |
| `name` | string | Long company / asset name |
| `price` | number | Current/latest price |
| `change` | number | Absolute change vs previous close |
| `changePercent` | number | % change vs previous close |
| `currency` | string | ISO currency code |
| `marketState` | string | `PRE`, `REGULAR`, `POST`, `POSTPOST`, `CLOSED` |
| `exchange` | string | Exchange name (`NasdaqGS`, `NYSE`, `CCC` for crypto, `CCY` for forex) |
| `previousClose`, `open`, `dayHigh`, `dayLow` | number | Intraday range |
| `volume`, `averageVolume` | number | Today's vs 3-month avg |
| `marketCap` | number | Equities/ETFs only |
| `fiftyTwoWeekHigh`, `fiftyTwoWeekLow` | number | 52-week range |
| `fiftyDayAverage`, `twoHundredDayAverage` | number | Moving averages |
| `preMarketPrice`, `postMarketPrice` | number | Extended hours (equities/ETFs) |
| `bid`, `ask` | number | Latest quote |
| `assetType` | string | `EQUITY`, `ETF`, `INDEX`, `CRYPTOCURRENCY`, `CURRENCY`, `MUTUALFUND`, `FUTURE` |
| `timestamp` | ISO 8601 | Yahoo's reported quote time (UTC) |

### Pricing — $0.001 per ticker

| Event | Price |
|---|---|
| Actor start | $0.00005 (per GB RAM) |
| Ticker price fetched | **$0.001** (per ticker successfully resolved) |

Failed tickers are **not charged**. Typical run cost:

- 10-ticker watchlist: **$0.01**
- 50-ticker portfolio: **$0.05**
- 500-ticker universe: **$0.50** (well under the $1 x402 default agent prepay)

### Quick start

#### Watchlist (concise output, ~150 tokens/row)

```json
{
  "tickers": ["AAPL", "MSFT", "NVDA", "TSLA", "GOOGL"],
  "responseFormat": "concise"
}
````

#### Mixed-asset portfolio (detailed output)

```json
{
  "tickers": [
    "AAPL", "MSFT",
    "BTC-USD", "ETH-USD",
    "^GSPC", "^IXIC",
    "EURUSD=X", "USDJPY=X",
    "GC=F", "CL=F",
    "VFIAX"
  ],
  "responseFormat": "detailed",
  "includePostMarket": true
}
```

#### Bulk universe (500 tickers, lower concurrency)

```json
{
  "tickers": ["AAPL", "MSFT", "..."],
  "responseFormat": "concise",
  "concurrency": 3
}
```

### Symbol formats — Yahoo Finance conventions

| Asset | Example | Notes |
|---|---|---|
| US stocks | `AAPL`, `TSLA`, `BRK-B` | No exchange suffix |
| Non-US stocks | `VOW3.DE`, `BABA.HK`, `7203.T`, `BARC.L` | `.DE` Xetra, `.HK` Hong Kong, `.T` Tokyo, `.L` London, `.F` Frankfurt |
| Indices | `^GSPC` (S\&P 500), `^DJI` (Dow), `^IXIC` (Nasdaq), `^FTSE`, `^N225` | Caret prefix |
| Crypto | `BTC-USD`, `ETH-USD`, `SOL-USD`, `DOGE-USD` | Dash, USD pair |
| Forex | `EURUSD=X`, `GBPUSD=X`, `USDJPY=X` | `=X` suffix |
| Mutual funds | `VFIAX`, `SWPPX`, `FXAIX` | Plain ticker |
| Futures | `ES=F` (S\&P), `CL=F` (oil), `GC=F` (gold) | `=F` suffix |
| ETFs | `SPY`, `QQQ`, `VTI`, `VOO` | Treated as equity |

The actor **auto-normalizes common alternate formats** — `AAPL:NASDAQ` → `AAPL`, `.DJI` → `^DJI`, `BTC/USD` → `BTC-USD`, `EUR/USD` → `EURUSD=X`. If you have legacy Google Finance ticker syntax in your pipeline, paste it as-is.

### Use cases

#### AI trading & portfolio agents (MCP-first)

```python
## Claude / GPT agent calling the actor via Apify MCP
quotes = mcp.call_actor(
    "khadinakbar/stock-price-tracker",
    input={"tickers": ["AAPL", "BTC-USD"], "responseFormat": "concise"},
)
## → ~300 tokens of clean JSON, ready to reason over
```

The output schema is **flat, semantically named, and consistent across runs** — exactly what an LLM tool-caller wants. `concise` mode keeps a 50-ticker portfolio under 8k tokens; `detailed` mode under 16k.

#### Scheduled watchlists

Run every 15 minutes via Apify Schedules:

```bash
apify schedule create \
  --actor khadinakbar/stock-price-tracker \
  --cron "*/15 9-17 * * 1-5" \
  --input '{"tickers": ["AAPL","MSFT","NVDA","GOOGL","META","TSLA"]}'
```

Each run pushes one row per ticker stamped with `timestamp` — the dataset becomes a price time-series for free.

#### Trading bots / alerting

Pair with a webhook or downstream actor that compares the latest `price` against a threshold. The detailed format includes `bid`/`ask` for spread checks and `volume`/`averageVolume` for liquidity filters.

#### Market research / dashboards

Pull a basket of tickers (sector ETFs + their components, or a custom factor universe) once a day and feed straight into a BI tool — fields are display-ready (`marketCap`, `fiftyTwoWeekHigh`, `twoHundredDayAverage`).

### When to use this actor — and when NOT to

✅ **Use this** for current/latest prices, watchlists, portfolio snapshots, market-state checks, agent tool calls.

❌ **Don't use this for**:

- **Historical OHLCV time-series** — use a dedicated history scraper. This actor returns the latest snapshot only.
- **Deep fundamentals** (P/E ratio, EPS, dividend history, analyst ratings, news) — use [google-finance-stock-news-scraper](https://apify.com/khadinakbar/google-finance-stock-news-scraper).
- **Symbol search by company name** — this actor takes exact Yahoo symbols only.
- **Streaming / sub-15s real-time** — Yahoo Finance is delayed 15 minutes for some exchanges; for true real-time you need a paid market-data feed.

### Reliability

- **Yahoo Finance v7 quote endpoint** (with crumb auth) is the primary path — single batched call for up to 50 tickers per request.
- **Yahoo Finance v8 chart endpoint** is the per-symbol fallback for any ticker the v7 batch couldn't resolve (delisted symbols, rare futures, exchange-specific edge cases). No crumb required, more permissive.
- **Crumb cookie auto-rotation** — the auth crumb is fetched once per run and cached for 30 minutes. On 401/403 it's invalidated and re-fetched automatically.
- **Concurrency-safe batching** — 50 symbols/batch, configurable parallel batches.
- **Per-ticker error rows** — when a symbol can't be resolved, you still get a row with `error`, `errorType`, and a fix suggestion. The dataset never silently drops a ticker.
- **No charge on failure** — `ticker-price-fetched` only fires when at least price/bid/ask is present.

### Output formats — concise vs detailed

`concise` (~150 tokens/row) — for AI agents, dashboards, watchlists where you only need the price + delta + market state. 9 fields.

`detailed` (~300 tokens/row, default) — full quote with day range, volume, market cap, 52-week range, moving averages, and pre/post-market prices. 25 fields.

For a 50-ticker run that's the difference between **7,500 tokens** (fits in a single agent prompt) and **15,000 tokens** (still fits in Claude's tool-output budget).

### Technical notes

- Built with **Crawlee + got-scraping** for proper TLS fingerprinting; no headless browser overhead.
- Apify Proxy enabled by default; works without proxy for small runs.
- Memory: 256 MB minimum, 512 MB default — light enough that a typical 50-ticker run costs ~$0.0001 in compute on top of PPE.
- Open-source actor pattern; outputs match the format expected by the [Apify MCP server](https://mcp.apify.com).

### Legal & data attribution

Stock, ETF, mutual fund, and index quotes are scraped from publicly accessible Yahoo Finance endpoints. Quote data is sourced and time-stamped per Yahoo Finance; consult Yahoo's terms before redistributing. This actor is independent of and not affiliated with Yahoo, Verizon, or Apollo Global Management. Use of this data for trading is at your own risk — Yahoo Finance prices are typically delayed 15 minutes for US equities and may not reflect best execution prices.

### Companion actors

- [Google Finance Stock & News Scraper](https://apify.com/khadinakbar/google-finance-stock-news-scraper) — deep fundamentals (P/E, EPS, dividends, news) per ticker.
- [Amazon Competitor Price Tracker](https://apify.com/khadinakbar/amazon-competitor-price-tracker) — same time-series pattern for Amazon ASINs.
- [AI Search Brand Monitor](https://apify.com/khadinakbar/ai-search-brand-monitor) — track brand visibility across LLM answers.

Browse the full portfolio at [apify.com/khadinakbar](https://apify.com/khadinakbar).

### Support

Open an issue on the actor's Apify Store page or reach out via [apify.com/khadinakbar](https://apify.com/khadinakbar). Pull-request style suggestions on input schema or output fields are welcome.

# Actor input Schema

## `tickers` (type: `array`):

Yahoo Finance ticker symbols (1-500 per run). Formats: US stocks plain ('AAPL'), non-US with suffix ('VOW3.DE', 'BABA.HK', 'BARC.L'), indices with caret ('^GSPC', '^DJI', '^IXIC'), crypto ('BTC-USD', 'ETH-USD'), forex ('EURUSD=X', 'USDJPY=X'), mutual funds ('VFIAX'), futures ('ES=F', 'GC=F'). Common alt formats auto-normalized (AAPL:NASDAQ, .DJI, BTC/USD). NOT a company-name search — exact symbols only.

## `responseFormat` (type: `string`):

Output detail level. 'concise' returns 9 essential fields per ticker (~150 tokens) ideal for AI agents and watchlists: ticker, name, price, change, changePercent, currency, marketState, exchange, timestamp. 'detailed' returns 20+ fields (~300 tokens) including dayHigh/Low, volume, marketCap, 52-week range, previousClose, open, postMarket data. Defaults to 'detailed'. NOT historical data — for OHLCV time-series use a dedicated history scraper.

## `includePostMarket` (type: `boolean`):

Include pre-market and post-market quote data when the market is closed or in extended hours. Adds preMarketPrice, preMarketChange, postMarketPrice, postMarketChange fields when applicable. Defaults to true. NOT applicable to crypto, forex, indices, or mutual funds (these markets do not have extended hours).

## `concurrency` (type: `integer`):

Number of concurrent HTTP requests to Yahoo Finance. Higher = faster but increases rate-limit risk. Recommended: 5 for ≤50 tickers, 3 for ≤200, 2 for >200. Maximum 10. Defaults to 5.

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

Apify proxy is recommended. Yahoo Finance is generally tolerant of datacenter IPs for the public quote endpoint, but residential proxies improve reliability under heavy load. Defaults to Apify Proxy with auto group selection.

## Actor input object example

```json
{
  "tickers": [
    "AAPL",
    "BTC-USD",
    "^GSPC"
  ],
  "responseFormat": "detailed",
  "includePostMarket": true,
  "concurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "tickers": [
        "AAPL",
        "TSLA",
        "MSFT",
        "NVDA",
        "GOOGL",
        "BTC-USD",
        "^GSPC",
        "EURUSD=X"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/stock-price-tracker").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 = { "tickers": [
        "AAPL",
        "TSLA",
        "MSFT",
        "NVDA",
        "GOOGL",
        "BTC-USD",
        "^GSPC",
        "EURUSD=X",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/stock-price-tracker").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 '{
  "tickers": [
    "AAPL",
    "TSLA",
    "MSFT",
    "NVDA",
    "GOOGL",
    "BTC-USD",
    "^GSPC",
    "EURUSD=X"
  ]
}' |
apify call khadinakbar/stock-price-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Stock Price Tracker — Real-Time Quotes (Stocks, Crypto, Forex)",
        "description": "Fetch real-time price quotes for stocks, ETFs, indices, crypto, forex, mutual funds, and futures from Yahoo Finance. Returns price, change, day range, volume, market cap, and 52-week range per ticker. Up to 500 symbols per run, sub-second per ticker, agent-friendly schema. $0.001/ticker.",
        "version": "0.1",
        "x-build-id": "GVnLU6JxuUJKeVOri"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~stock-price-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-stock-price-tracker",
                "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~stock-price-tracker/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-stock-price-tracker",
                "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~stock-price-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-stock-price-tracker",
                "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": [
                    "tickers"
                ],
                "properties": {
                    "tickers": {
                        "title": "Tickers / symbols to fetch",
                        "minItems": 1,
                        "maxItems": 500,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Yahoo Finance ticker symbols (1-500 per run). Formats: US stocks plain ('AAPL'), non-US with suffix ('VOW3.DE', 'BABA.HK', 'BARC.L'), indices with caret ('^GSPC', '^DJI', '^IXIC'), crypto ('BTC-USD', 'ETH-USD'), forex ('EURUSD=X', 'USDJPY=X'), mutual funds ('VFIAX'), futures ('ES=F', 'GC=F'). Common alt formats auto-normalized (AAPL:NASDAQ, .DJI, BTC/USD). NOT a company-name search — exact symbols only.",
                        "default": [
                            "AAPL",
                            "TSLA",
                            "MSFT",
                            "NVDA",
                            "GOOGL"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "responseFormat": {
                        "title": "Response format",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Output detail level. 'concise' returns 9 essential fields per ticker (~150 tokens) ideal for AI agents and watchlists: ticker, name, price, change, changePercent, currency, marketState, exchange, timestamp. 'detailed' returns 20+ fields (~300 tokens) including dayHigh/Low, volume, marketCap, 52-week range, previousClose, open, postMarket data. Defaults to 'detailed'. NOT historical data — for OHLCV time-series use a dedicated history scraper.",
                        "default": "detailed"
                    },
                    "includePostMarket": {
                        "title": "Include pre/post-market prices",
                        "type": "boolean",
                        "description": "Include pre-market and post-market quote data when the market is closed or in extended hours. Adds preMarketPrice, preMarketChange, postMarketPrice, postMarketChange fields when applicable. Defaults to true. NOT applicable to crypto, forex, indices, or mutual funds (these markets do not have extended hours).",
                        "default": true
                    },
                    "concurrency": {
                        "title": "Parallel requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of concurrent HTTP requests to Yahoo Finance. Higher = faster but increases rate-limit risk. Recommended: 5 for ≤50 tickers, 3 for ≤200, 2 for >200. Maximum 10. Defaults to 5.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy is recommended. Yahoo Finance is generally tolerant of datacenter IPs for the public quote endpoint, but residential proxies improve reliability under heavy load. Defaults to Apify Proxy with auto group selection.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
