# TradingView Screener (`khadinakbar/tradingview-screener`) Actor

Screen stocks, crypto, forex & futures on TradingView with preset scans, custom filters, and selectable columns. HTTP-only, MCP-ready, $0.004 per result.

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

## Pricing

from $4.00 / 1,000 result returneds

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

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

## What's an Apify Actor?

Actors are 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

## TradingView Screener

Screen **stocks, crypto, forex, and futures** across every TradingView market — by ready-made **preset scan** or your own **custom filters** — and get the true top-N of the whole market as clean JSON. Built on TradingView's own public scanner backend, so results match what you see on tradingview.com/screener. HTTP-only, fast, MCP-ready.

### What you get

- **12 preset scans** — top gainers, top losers, most active, unusual volume, oversold RSI, overbought RSI, Strong Buy, Strong Sell, high dividend, large cap, small-cap gainers, high volatility. Pick one and run; nothing else required.
- **Custom filters** — build any screen from `{ field, operation, value }` rules (`RSI < 30`, `market_cap_basic >= 1B`, `dividend_yield_recent in_range [5,15]`), all AND-combined and stacked on top of a preset.
- **Every market** — `america`, `crypto`, `forex`, `futures`, plus 35+ country codes (`uk`, `germany`, `india`, `canada`, `japan`, …).
- **Selectable columns** — 20 rich fields by default; add any TradingView column ID (`MACD.macd`, `EMA200`, `price_book_fq`) when you need more.
- **Server-side sort** — you get the real top-50 of a 13,000-symbol market, not a page you have to re-rank.

### When to use it

- Quant / algo watchlist building and daily signal generation.
- Momentum, mean-reversion, dividend, and value screens on a schedule.
- Feeding an AI trading agent a filtered market snapshot as a single tool call.
- Cross-market scanning (screen US equities and crypto in separate runs, same schema).

**Not for:** single-symbol quotes or the multi-timeframe TA gauge — use the companion **[TradingView Scraper](https://apify.com/khadinakbar/tradingview-scraper)** for those. This actor ranks a whole market; it does not fetch one ticker.

### Output

One ranked record per matched symbol:

| Field | Description |
|---|---|
| `rank` | 1-based position in the sorted set |
| `fullSymbol` | `EXCHANGE:SYMBOL` (e.g., `NASDAQ:AAPL`) |
| `symbol` / `exchange` | Split components |
| `companyName` | Human-readable name |
| `close` / `changePct` | Latest price and daily % change |
| `volume` / `relativeVolume` | Session volume and volume vs 10-day average |
| `marketCapUsd` / `peRatio` / `eps` | Fundamentals |
| `dividendYieldPct` | Recent dividend yield |
| `sector` / `industry` / `country` / `currency` | Classification |
| `rsi` / `recommendAll` / `recommendAllLabel` | RSI and TA rating (-1..1 + Strong Buy...Strong Sell) |
| `perfWeek` / `perfMonth` / `perfYTD` | Performance windows |
| `high52w` / `low52w` | 52-week range |
| `url` | Direct TradingView symbol link |
| `scrapedAt` | ISO 8601 UTC timestamp |

#### Sample record

```json
{
  "rank": 1,
  "fullSymbol": "NASDAQ:AMBA",
  "companyName": "Ambarella, Inc.",
  "close": 85.8,
  "changePct": 28.04,
  "volume": 7006565,
  "relativeVolume": 5.53,
  "marketCapUsd": 3763890233,
  "rsi": 63.76,
  "recommendAll": 0.648,
  "recommendAllLabel": "Strong Buy",
  "sector": "Electronic Technology",
  "high52w": 96.69,
  "low52w": 48.3,
  "url": "https://www.tradingview.com/symbols/NASDAQ-AMBA/",
  "scrapedAt": "2026-07-01T10:57:27.035Z"
}
````

### Pricing

**$0.004 per result returned** + a $0.00005 actor-start fee. `maxResults` (max 500) is your hard cost cap — a 50-row screen costs **$0.20**, a full 500-row scan costs **$2.00**. Pay-per-event and pay-per-usage are both enabled; pick whichever billing fits at run time.

### Quick start

Run the **top US gainers** with no configuration — the default input is a complete screen:

```json
{ "preset": "top_gainers", "market": "america", "maxResults": 50 }
```

#### Oversold large-cap crypto

```json
{ "preset": "oversold_rsi", "market": "crypto", "maxResults": 30 }
```

#### Custom: high-yield US stocks under a P/E of 15

```json
{
  "preset": "none",
  "market": "america",
  "filters": [
    { "field": "dividend_yield_recent", "operation": "gte", "value": 4 },
    { "field": "price_earnings_ttm", "operation": "in_range", "value": [0, 15] },
    { "field": "market_cap_basic", "operation": "gte", "value": 2000000000 }
  ],
  "sortBy": "dividend_yield_recent",
  "sortOrder": "desc",
  "maxResults": 50
}
```

#### Preset + extra filter + extra columns

```json
{
  "preset": "unusual_volume",
  "market": "america",
  "filters": [{ "field": "RSI", "operation": "lt", "value": 40 }],
  "columns": ["MACD.macd", "EMA200"],
  "maxResults": 25
}
```

### Filter operations

| Operation | Meaning | `value` shape |
|---|---|---|
| `gt` / `gte` / `lt` / `lte` | > / >= / < / <= | number |
| `eq` / `neq` | equals / not equals | number, string, or boolean |
| `in_range` / `not_in_range` | inside / outside a range | `[min, max]` |
| `crosses_above` / `crosses_below` | series cross | column ID or number |
| `above` / `below` | above / below | column ID or number |
| `nempty` / `empty` | has a value / is blank | *(none)* |
| `has` | set membership | `["common"]` |

Bad filters are skipped with a warning (recorded in the run `SUMMARY`), never crashing the run.

### Common TradingView column IDs

`change`, `close`, `volume`, `relative_volume_10d_calc`, `market_cap_basic`, `price_earnings_ttm`, `earnings_per_share_basic_ttm`, `dividend_yield_recent`, `RSI`, `Recommend.All`, `MACD.macd`, `Stoch.K`, `ADX`, `EMA50`, `EMA200`, `SMA200`, `Perf.W`, `Perf.1M`, `Perf.YTD`, `Volatility.D`, `price_52_week_high`, `price_52_week_low`, `sector`, `industry`, `country`.

### MCP / AI agents

Exposed via Apify MCP as `apify--khadinakbar/tradingview-screener`. A single call returns a ranked, filtered market snapshot in flat JSON — ideal as a tool for trading/research agents. Each row stays compact so agents can sample dozens without blowing their context budget.

### Notes & limitations

- **Data is delayed** ~15-20 minutes for US equities and real-time for crypto — this is a **screening** tool, not for HFT execution.
- Quality presets on equity markets exclude non-primary listings, warrants, and preferreds (`is_primary` + common-stock only) so you don't get penny-stock noise. Crypto/forex presets skip those filters (they don't apply).
- `minMarketCapUsd` and market-cap filters are ignored on `forex`/`futures` where market cap has no meaning.

### Legal

This actor collects publicly available data from TradingView's public scanner endpoint. It performs no login and accesses no gated or personal data. You are responsible for complying with TradingView's Terms of Service and applicable laws in your jurisdiction. Financial data is provided "as is" for informational purposes only and is not investment advice.

# Actor input Schema

## `preset` (type: `string`):

A ready-made screen that sets sensible filters and sort for you (e.g., 'top\_gainers' returns the day's biggest movers with a market-cap floor and junk filtered out). Pick one and you need nothing else to run. Set to 'none' to build your own screen with the Filters field below. Presets combine with any extra Filters you add.

## `market` (type: `string`):

Which TradingView market universe to screen. Use 'america' for US stocks (NASDAQ/NYSE/AMEX), 'crypto' for coins, 'forex' for currency pairs, 'futures' for futures, or a country code like 'uk', 'germany', 'india', 'canada', 'japan'. Defaults to 'america'. This is the exchange universe, NOT a single ticker - this actor ranks a whole market, it does not fetch one symbol.

## `filters` (type: `array`):

Advanced: build your own screen as a list of { field, operation, value } rules, all AND-combined (e.g., \[{"field":"RSI","operation":"lt","value":30},{"field":"market\_cap\_basic","operation":"gte","value":1000000000}]). Operations: gt, gte, lt, lte, eq, neq, in\_range (value=\[min,max]), crosses\_above, crosses\_below, nempty, has. Field names are TradingView column IDs (RSI, change, market\_cap\_basic, dividend\_yield\_recent, Recommend.All, Perf.YTD). Leave empty to rely on the Preset; filters here are added on top of the preset.

## `columns` (type: `array`):

Advanced: extra TradingView column IDs to include in each result beyond the ~20 rich defaults (e.g., \["MACD.macd","EMA200","price\_book\_fq"]). Unknown columns are returned under a camelCase key; known ones get friendly names (RSI to rsi, market\_cap\_basic to marketCapUsd). Leave empty for the default field set. This does NOT filter - use Filters for that.

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

TradingView column ID to sort results by, overriding the preset's sort (e.g., 'change', 'volume', 'market\_cap\_basic', 'dividend\_yield\_recent', 'Perf.YTD'). Leave empty to use the preset's sort, or 'market\_cap\_basic' when no preset is set. Sorting is server-side, so you get the true top-N of the whole market. Not a filter - it only orders the matched rows.

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

Direction for Sort by column. 'desc' = highest first (biggest gainers, largest cap), 'asc' = lowest first (biggest losers, most oversold). Overrides the preset's default order. Ignored when no sort column applies.

## `minMarketCapUsd` (type: `integer`):

Convenience floor: drop any symbol below this market cap in USD (e.g., 1000000000 = $1B, filters out micro-caps and penny stocks). Applies on top of the preset and any custom filters. Set 0 to disable. Ignored on forex/futures where market cap has no meaning.

## `maxResults` (type: `integer`):

How many top-ranked symbols to return (1-500). One scan run returns up to this many rows, sorted server-side, so 50 gives the true top 50 of the whole market. Defaults to 50. Each returned row is billed once, so this is also your hard cost cap.

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

Proxy used for the TradingView scanner request. The default Apify datacenter proxy works - the endpoint is public and has no anti-bot - so you can leave this untouched. Switch to Residential only if you hit rare rate limits on very high-frequency scheduling.

## Actor input object example

```json
{
  "preset": "top_gainers",
  "market": "america",
  "filters": [],
  "columns": [],
  "sortBy": "change",
  "sortOrder": "desc",
  "minMarketCapUsd": 1000000000,
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

One record per matched symbol, ranked. See dataset\_schema.json for field documentation.

## `summary` (type: `string`):

Aggregate counts, total matched, billed USD, and any warnings for this run.

# 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 = {
    "preset": "top_gainers",
    "market": "america",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/tradingview-screener").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 = {
    "preset": "top_gainers",
    "market": "america",
    "maxResults": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/tradingview-screener").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 '{
  "preset": "top_gainers",
  "market": "america",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/tradingview-screener --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradingView Screener",
        "description": "Screen stocks, crypto, forex & futures on TradingView with preset scans, custom filters, and selectable columns. HTTP-only, MCP-ready, $0.004 per result.",
        "version": "0.1",
        "x-build-id": "4pqzwO4M9Wl1uFuIa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~tradingview-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-tradingview-screener",
                "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~tradingview-screener/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-tradingview-screener",
                "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~tradingview-screener/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-tradingview-screener",
                "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",
                "properties": {
                    "preset": {
                        "title": "Preset scan",
                        "enum": [
                            "top_gainers",
                            "top_losers",
                            "most_active",
                            "unusual_volume",
                            "oversold_rsi",
                            "overbought_rsi",
                            "strong_buy",
                            "strong_sell",
                            "high_dividend",
                            "large_cap",
                            "small_cap_gainers",
                            "high_volatility",
                            "none"
                        ],
                        "type": "string",
                        "description": "A ready-made screen that sets sensible filters and sort for you (e.g., 'top_gainers' returns the day's biggest movers with a market-cap floor and junk filtered out). Pick one and you need nothing else to run. Set to 'none' to build your own screen with the Filters field below. Presets combine with any extra Filters you add.",
                        "default": "top_gainers"
                    },
                    "market": {
                        "title": "Market",
                        "enum": [
                            "america",
                            "crypto",
                            "forex",
                            "futures",
                            "cfd",
                            "bond",
                            "uk",
                            "germany",
                            "france",
                            "spain",
                            "italy",
                            "switzerland",
                            "netherlands",
                            "sweden",
                            "poland",
                            "turkey",
                            "russia",
                            "canada",
                            "mexico",
                            "brazil",
                            "argentina",
                            "australia",
                            "japan",
                            "china",
                            "hongkong",
                            "india",
                            "korea",
                            "taiwan",
                            "singapore",
                            "indonesia",
                            "malaysia",
                            "thailand",
                            "vietnam",
                            "philippines",
                            "uae",
                            "saudiarabia",
                            "egypt",
                            "israel",
                            "southafrica",
                            "nigeria"
                        ],
                        "type": "string",
                        "description": "Which TradingView market universe to screen. Use 'america' for US stocks (NASDAQ/NYSE/AMEX), 'crypto' for coins, 'forex' for currency pairs, 'futures' for futures, or a country code like 'uk', 'germany', 'india', 'canada', 'japan'. Defaults to 'america'. This is the exchange universe, NOT a single ticker - this actor ranks a whole market, it does not fetch one symbol.",
                        "default": "america"
                    },
                    "filters": {
                        "title": "Custom filters",
                        "type": "array",
                        "description": "Advanced: build your own screen as a list of { field, operation, value } rules, all AND-combined (e.g., [{\"field\":\"RSI\",\"operation\":\"lt\",\"value\":30},{\"field\":\"market_cap_basic\",\"operation\":\"gte\",\"value\":1000000000}]). Operations: gt, gte, lt, lte, eq, neq, in_range (value=[min,max]), crosses_above, crosses_below, nempty, has. Field names are TradingView column IDs (RSI, change, market_cap_basic, dividend_yield_recent, Recommend.All, Perf.YTD). Leave empty to rely on the Preset; filters here are added on top of the preset.",
                        "default": []
                    },
                    "columns": {
                        "title": "Extra columns",
                        "type": "array",
                        "description": "Advanced: extra TradingView column IDs to include in each result beyond the ~20 rich defaults (e.g., [\"MACD.macd\",\"EMA200\",\"price_book_fq\"]). Unknown columns are returned under a camelCase key; known ones get friendly names (RSI to rsi, market_cap_basic to marketCapUsd). Leave empty for the default field set. This does NOT filter - use Filters for that.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by column",
                        "type": "string",
                        "description": "TradingView column ID to sort results by, overriding the preset's sort (e.g., 'change', 'volume', 'market_cap_basic', 'dividend_yield_recent', 'Perf.YTD'). Leave empty to use the preset's sort, or 'market_cap_basic' when no preset is set. Sorting is server-side, so you get the true top-N of the whole market. Not a filter - it only orders the matched rows."
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Direction for Sort by column. 'desc' = highest first (biggest gainers, largest cap), 'asc' = lowest first (biggest losers, most oversold). Overrides the preset's default order. Ignored when no sort column applies.",
                        "default": "desc"
                    },
                    "minMarketCapUsd": {
                        "title": "Minimum market cap (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Convenience floor: drop any symbol below this market cap in USD (e.g., 1000000000 = $1B, filters out micro-caps and penny stocks). Applies on top of the preset and any custom filters. Set 0 to disable. Ignored on forex/futures where market cap has no meaning.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many top-ranked symbols to return (1-500). One scan run returns up to this many rows, sorted server-side, so 50 gives the true top 50 of the whole market. Defaults to 50. Each returned row is billed once, so this is also your hard cost cap.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for the TradingView scanner request. The default Apify datacenter proxy works - the endpoint is public and has no anti-bot - so you can leave this untouched. Switch to Residential only if you hit rare rate limits on very high-frequency scheduling.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
