# 📊 ETF Holdings Tracker — Constituents, Weights, AUM (`nexgendata/etf-holdings-tracker`) Actor Track ETF constituent holdings, weights, AUM, sector exposure across 100+ major US ETFs including SPY, QQQ, VTI, ARKK, JEPI. Daily holdings data for asset allocators, ETF arbitrageurs, factor investors, index researchers. Bloomberg ETF analytics alternative — pay-per-result, no Bloomberg seat. - **URL**: https://apify.com/nexgendata/etf-holdings-tracker.md - **Developed by:** [NexGenData](https://apify.com/nexgendata) (community) - **Categories:** Business, Automation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $100.00 / 1,000 etf holding records 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 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 ## 📊 ETF Holdings Tracker — Constituents, Weights, AUM **Pay-per-result ETF holdings data — $0.10 per constituent record. No Bloomberg seat, no FactSet contract, no per-symbol licensing wall.** Track the full constituent baskets of 100+ major US ETFs — SPY, QQQ, IWM, VTI, VOO, IVV, EFA, EEM, AGG, BND, GLD, SLV, the XL* sector SPDRs, the ARK family, JEPI, SCHD, VIG, VWO, VEA, IEMG, IEFA, TQQQ, SQQQ, ARKK, ARKQ, ARKW, ARKG, plus the long tail of iShares, Vanguard, State Street, Invesco, ProShares, First Trust, Direxion, Schwab, JPMorgan, WisdomTree, Global X, KraneShares, VanEck, Pacer and Fidelity products. Every constituent is emitted as a discrete record with ETF symbol, ETF name, ETF issuer, ETF AUM, holding symbol, holding name, weight %, shares held, market value, sector, and country. This actor is purpose-built for the four buy-side workflows where ETF holdings data is mission-critical: - **Asset allocators** decomposing thematic / sector / factor ETF exposure into underlying GICS sectors and country breakdowns - **ETF arbitrageurs** computing NAV deltas vs the live constituent basket and surfacing intraday creation / redemption opportunities - **Factor investors** reverse-engineering a fund's beta to value, momentum, quality, low-volatility and size factors from the holding list - **Indexers** tracking constituent adds, drops and reweights week-over-week across iShares, Vanguard and SPDR sleeves to anticipate front-running flows --- ### What you get per record Each emitted record represents one ETF-constituent pair. Pull SPY and you'll get ~500 records; pull QQQ and you'll get ~100; pull ARKK and you'll get ~30. Records carry: - `etf_symbol` — parent ETF ticker (SPY, QQQ, VTI, ARKK, JEPI, etc.) - `etf_name` — full fund name as reported by the issuer - `etf_issuer` — sponsor (iShares / Vanguard / State Street / Invesco / ARK / JPMorgan / Schwab / WisdomTree / ProShares / Direxion / Global X / KraneShares / VanEck / First Trust / Pacer / Fidelity) - `etf_aum_usd` — total net assets in raw USD - `etf_aum_billion_usd` — total net assets in USD billions (3-decimal precision) - `holding_symbol` — constituent ticker - `holding_name` — constituent company name - `holding_sector` — best-effort GICS sector inference for the constituent - `weight_pct` — constituent weight as % of ETF AUM (e.g. NVDA = 8.17% of SPY) - `shares_held` — share count held by the ETF - `market_value_usd` — derived dollar value = AUM × weight% - `holding_country` — issuer country of incorporation (for international/global ETFs like EEM, EFA, KWEB, EWJ) - `as_of_date` — issuer-reported holdings date (defaults to today if absent) - `etf_holdings_url` — direct deep-link to the source holdings page - `data_source` — provenance flag ### Input parameters - `etf_symbols` — array of ETF tickers to pull (default: `["SPY", "QQQ", "VTI"]`) - `limit` — hard cap on total holding records returned across all ETFs (default 1000, max 50000). Use this to bound cost. - `max_holdings_per_etf` — cap per ETF (default 100, 0 = full holdings). SPY has ~500, VTI ~3700, ARKK ~30. Most analytics workflows need only the top 50-100 names by weight. - `min_weight_pct` — filter out long-tail holdings below this weight (default 0). Use 0.5 to keep only meaningful positions, 1.0 for top-decile names. - `country` — filter holdings by issuer country of incorporation. Primarily useful for international / global ETFs (EEM, EFA, KWEB, EWJ, IEMG, IEFA, VWO). - `issuer` — filter the requested ETFs by sponsor when you pass a long ETF list but only want (e.g.) iShares funds. ### How it works The actor probes per-ETF holdings tables from `stockanalysis.com/etf/{symbol}/holdings/` — clean server-rendered HTML with up to ~500 holdings per ETF and weight + share-count columns straight from the daily issuer disclosure. For each ETF symbol passed in, the actor also fetches the overview page at `/etf/{symbol}/` to recover the fund's official name, total AUM, sponsor, and as-of date. Both pages are pulled concurrently per ETF so a 10-ETF run completes in seconds, not minutes. We then merge per-ETF metadata into every constituent row, derive `market_value_usd` from `AUM × weight%`, infer the holding's GICS sector from a curated S&P 500 lookup table (with name-keyword fallback for off-index names), and tag the holding's country of incorporation from a known-name / suffix map. Final filtering by `min_weight_pct`, `country`, `issuer` and the global `limit` happens just before the push, so you only pay for records that match your spec. ### Pricing & cost model PAY_PER_EVENT: - `Actor start` — $0.01 (charged once per run) - `ETF holding record` — $0.10 per emitted dataset item (primary event) Cost examples: - Top-10 holdings of SPY → $0.01 + 10 × $0.10 = **$1.01** - Top-100 holdings of SPY, QQQ, VTI (default input) → $0.01 + 300 × $0.10 = **$30.01** - Full SPY constituent basket (~500 names) → $0.01 + 500 × $0.10 = **$50.01** - Full top-100 of all 11 sector SPDRs (XLK, XLF, XLE, XLI, XLV, XLY, XLP, XLU, XLB, XLRE, XLC) → $0.01 + 1100 × $0.10 = **$110.01** This pricing is deliberately positioned mid-premium — well below the IPO-tracker rate ($0.50/event) because holdings records are volume-heavy, but well above thin-ticker screener rates ($0.02-0.05) because each record carries six fund-level joins of metadata plus four constituent-level derivations. ### How this compares to Bloomberg / FactSet / Refinitiv / etf.com Pro | Platform | Coverage | Annual cost | Daily holdings refresh | Programmatic API | | --- | --- | --- | --- | --- | | Bloomberg Terminal (ETF analytics) | All US + international ETFs | ~$24,000 / seat / year | Yes | Yes (BLPAPI, seat-locked) | | FactSet ETF Solutions | 8000+ ETFs globally | ~$12,000 / seat / year | Yes | Yes (FactSet API) | | Refinitiv Workspace ETF | Global ETFs | ~$22,000 / seat / year | Yes | Yes (Refinitiv Data Platform) | | etf.com Pro | US ETFs | ~$2,400 / year | Daily | Limited (CSV export only) | | **ETF Holdings Tracker (this actor)** | **100+ major US ETFs** | **Pay-per-record, no subscription** | **Yes (daily issuer disclosure)** | **Yes (Apify REST API + webhooks)** | If you need full global ETF coverage, real-time intraday holdings updates, and a full Bloomberg-grade analytics workspace, you're still going to pay for a terminal. But if your workflow is: - A weekly rebalance check of 10-30 ETF baskets - A factor decomposition pipeline that ingests holdings once per week - A retail-facing ETF lookup tool that doesn't need a $24k/year per-seat data backend - An academic / research workflow that needs holdings but not the rest of a terminal … then paying per holding record is the right cost model and this actor is a 90%+ savings vs the incumbents. ### Sister actors in the NexGenData fleet This actor is part of a financial-data fleet on Apify. Combine these to build a full data backend without a Bloomberg seat: - [**Finviz Stock Screener**](https://apify.com/nexgendata/finviz-stock-screener) — US equities filtered by sector, fundamentals, technicals (the equity universe behind every ETF) - [**SEC Form 13F Holdings Tracker**](https://apify.com/nexgendata/sec-form-13f-holdings-tracker) — quarterly institutional holdings (the buy-side counterpart to ETF holdings) - [**Chinese ADRs Stock Screener**](https://apify.com/nexgendata/chinese-adrs-stock-screener) — US-listed Chinese ADRs (the names you'll find inside KWEB, MCHI, FXI, ASHR) - [**TSE Japan Stock Screener**](https://apify.com/nexgendata/tse-japan-stock-screener) — Tokyo-listed names (constituent universe for EWJ, DXJ, BBJP) - [**LSE UK Stock Screener**](https://apify.com/nexgendata/lse-uk-stock-screener) — London-listed names (constituent universe for EWU, FLGB, HEWU) - [**Finance MCP Server**](https://apify.com/nexgendata/finance-mcp-server) — model-context-protocol bridge so you can pull these screeners from Claude, GPT, Cursor and any other MCP-capable client ### Output schema Each record: ```json { "etf_symbol": "SPY", "etf_name": "SPDR S&P 500 ETF Trust", "etf_issuer": "State Street", "etf_aum_billion_usd": 762.12, "etf_aum_usd": 762120000000.0, "holding_symbol": "NVDA", "holding_name": "NVIDIA Corporation", "holding_sector": "Technology", "weight_pct": 8.17, "shares_held": 290262607, "market_value_usd": 62265204000.0, "holding_country": "United States", "as_of_date": "2026-05-10", "etf_holdings_url": "https://stockanalysis.com/etf/spy/holdings/", "data_source": "stockanalysis.com" } ```` ### Common recipes **Top-10 sector SPDRs basket review:** `{"etf_symbols": ["XLK", "XLF", "XLE", "XLI", "XLV", "XLY", "XLP", "XLU", "XLB", "XLRE", "XLC"], "max_holdings_per_etf": 10}` — 110 records, $11.01. **ARK family decomposition:** `{"etf_symbols": ["ARKK", "ARKQ", "ARKW", "ARKG", "ARKF", "ARKX"], "max_holdings_per_etf": 50, "min_weight_pct": 0.5}` — gets every meaningful position across the entire ARK lineup for cross-fund overlap analysis. **Core 3-fund portfolio audit:** `{"etf_symbols": ["VTI", "VXUS", "BND"], "max_holdings_per_etf": 100}` — the basket behind the Boglehead three-fund portfolio. **Income / dividend ETFs:** `{"etf_symbols": ["SCHD", "VIG", "VYM", "JEPI", "JEPQ", "DIVO", "SDY"], "max_holdings_per_etf": 50}` — full breakdown of the high-yield ETF complex. **International decomposition by country:** `{"etf_symbols": ["EEM", "EFA", "IEMG", "IEFA", "VWO", "VEA"], "country": "China", "max_holdings_per_etf": 100}` — isolates only the Chinese holdings inside each broad EM/DM ETF. **Leveraged / inverse:** `{"etf_symbols": ["TQQQ", "SQQQ", "SOXL", "SOXS", "UPRO", "SPXU"], "max_holdings_per_etf": 50}` — the swap basket behind the 3x products. ### Reliability & maintenance The actor degrades gracefully — if `stockanalysis.com` returns non-200 for a single ETF, that ETF is skipped and the rest of the run continues. AUM and as-of date are best-effort; if either is unavailable the record still emits with the fund-level fields nulled and `as_of_date` defaulting to today. Sector and country inference are heuristic — they cover the S\&P 500 universe directly and use name-keyword fallback for off-index names; consumers who need authoritative GICS classifications should join against Finviz or Refinitiv downstream. ### Affiliate & support Built and maintained by NexGenData on the Apify platform. Discover the full fleet of 50+ stock screeners, fundamentals trackers, SEC filing harvesters and financial-data MCP servers here: **** # Actor input Schema ## `etf_symbols` (type: `array`): List of US-listed ETF tickers to pull holdings for. Each ETF is fetched independently and emits one holding record per constituent (typically 10-500 constituents per ETF depending on the index). Defaults to the three most-traded core ETFs (SPY/QQQ/VTI). Supports all 100+ ETFs covered by stockanalysis.com including iShares, Vanguard, State Street, Invesco, ARK, JPMorgan, Schwab issuers. ## `limit` (type: `integer`): Hard cap on total holding records emitted across every ETF requested. Set to 0 to disable the cap (you'll get every constituent of every ETF). This caps the dataset AFTER per-ETF max\_holdings\_per\_etf has been applied — use it to bound cost. ## `max_holdings_per_etf` (type: `integer`): Cap on constituents returned per ETF. SPY has ~500, QQQ ~100, VTI ~3700, ARKK ~30. Use 10 for top-10 sampling, 100 for top-100 (standard institutional reporting), 0 for full holdings. Most ETF analytics workflows only need the top 50-100 names by weight. ## `min_weight_pct` (type: `number`): Filter out tiny long-tail holdings below this weight threshold (in percent of ETF AUM). Use 0.5 to keep only meaningful positions (>0.5% of AUM), 1.0 for top-decile positions, 0 for everything including 0.01% positions. Useful for factor research where small-weight holdings are noise. ## `country` (type: `string`): Filter holdings by issuer country of incorporation. 'all' returns everything; pick a specific country to isolate (for example) Chinese ADRs inside KWEB or Japanese names inside EWJ. Most US-domiciled ETFs are 100% US holdings — this is primarily useful for international/global ETFs like EEM, EFA, VEA, IEMG. ## `issuer` (type: `string`): Filter the requested ETFs by sponsor. Useful when you pass a long list of tickers but only want (e.g.) all iShares ETFs. 'all' returns every issuer. Issuer is inferred from the ETF's name. ## Actor input object example ```json { "etf_symbols": [ "SPY", "QQQ", "VTI" ], "limit": 1000, "max_holdings_per_etf": 100, "min_weight_pct": 0, "country": "all", "issuer": "all" } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "etf_symbols": [ "SPY", "QQQ", "VTI" ], "limit": 1000, "max_holdings_per_etf": 100, "min_weight_pct": 0, "country": "all", "issuer": "all" }; // Run the Actor and wait for it to finish const run = await client.actor("nexgendata/etf-holdings-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "etf_symbols": [ "SPY", "QQQ", "VTI", ], "limit": 1000, "max_holdings_per_etf": 100, "min_weight_pct": 0, "country": "all", "issuer": "all", } # Run the Actor and wait for it to finish run = client.actor("nexgendata/etf-holdings-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 '{ "etf_symbols": [ "SPY", "QQQ", "VTI" ], "limit": 1000, "max_holdings_per_etf": 100, "min_weight_pct": 0, "country": "all", "issuer": "all" }' | apify call nexgendata/etf-holdings-tracker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=nexgendata/etf-holdings-tracker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "📊 ETF Holdings Tracker — Constituents, Weights, AUM", "description": "Track ETF constituent holdings, weights, AUM, sector exposure across 100+ major US ETFs including SPY, QQQ, VTI, ARKK, JEPI. Daily holdings data for asset allocators, ETF arbitrageurs, factor investors, index researchers. Bloomberg ETF analytics alternative — pay-per-result, no Bloomberg seat.", "version": "0.0", "x-build-id": "hXHN4JNuh9dqqR8dT" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/nexgendata~etf-holdings-tracker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-nexgendata-etf-holdings-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/nexgendata~etf-holdings-tracker/runs": { "post": { "operationId": "runs-sync-nexgendata-etf-holdings-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/nexgendata~etf-holdings-tracker/run-sync": { "post": { "operationId": "run-sync-nexgendata-etf-holdings-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", "properties": { "etf_symbols": { "title": "ETF tickers", "type": "array", "description": "List of US-listed ETF tickers to pull holdings for. Each ETF is fetched independently and emits one holding record per constituent (typically 10-500 constituents per ETF depending on the index). Defaults to the three most-traded core ETFs (SPY/QQQ/VTI). Supports all 100+ ETFs covered by stockanalysis.com including iShares, Vanguard, State Street, Invesco, ARK, JPMorgan, Schwab issuers.", "default": [ "SPY", "QQQ", "VTI" ], "items": { "type": "string" } }, "limit": { "title": "Maximum holding records to return (across all ETFs)", "minimum": 0, "maximum": 50000, "type": "integer", "description": "Hard cap on total holding records emitted across every ETF requested. Set to 0 to disable the cap (you'll get every constituent of every ETF). This caps the dataset AFTER per-ETF max_holdings_per_etf has been applied — use it to bound cost.", "default": 1000 }, "max_holdings_per_etf": { "title": "Maximum holdings per ETF", "minimum": 0, "maximum": 5000, "type": "integer", "description": "Cap on constituents returned per ETF. SPY has ~500, QQQ ~100, VTI ~3700, ARKK ~30. Use 10 for top-10 sampling, 100 for top-100 (standard institutional reporting), 0 for full holdings. Most ETF analytics workflows only need the top 50-100 names by weight.", "default": 100 }, "min_weight_pct": { "title": "Minimum constituent weight (%)", "minimum": 0, "maximum": 100, "type": "number", "description": "Filter out tiny long-tail holdings below this weight threshold (in percent of ETF AUM). Use 0.5 to keep only meaningful positions (>0.5% of AUM), 1.0 for top-decile positions, 0 for everything including 0.01% positions. Useful for factor research where small-weight holdings are noise.", "default": 0 }, "country": { "title": "Holding country filter", "enum": [ "all", "United States", "China", "Japan", "United Kingdom", "Canada", "Germany", "France", "Switzerland", "Taiwan", "India", "Brazil", "South Korea", "Netherlands", "Australia" ], "type": "string", "description": "Filter holdings by issuer country of incorporation. 'all' returns everything; pick a specific country to isolate (for example) Chinese ADRs inside KWEB or Japanese names inside EWJ. Most US-domiciled ETFs are 100% US holdings — this is primarily useful for international/global ETFs like EEM, EFA, VEA, IEMG.", "default": "all" }, "issuer": { "title": "ETF issuer filter", "enum": [ "all", "iShares", "Vanguard", "State Street", "Invesco", "ARK", "JPMorgan", "Schwab", "First Trust", "Direxion", "ProShares", "WisdomTree" ], "type": "string", "description": "Filter the requested ETFs by sponsor. Useful when you pass a long list of tickers but only want (e.g.) all iShares ETFs. 'all' returns every issuer. Issuer is inferred from the ETF's name.", "default": "all" } } }, "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 } } } } } } } } } } ```