# AWS Bedrock Models Scraper (`automation-lab/aws-bedrock-models-scraper`) Actor Scrapes the full AWS Bedrock model catalog from the official AWS documentation. Returns all foundation models available on Amazon Bedrock with provider name, model name, model card URL, and optionally detailed specs from each model card page. - **URL**: https://apify.com/automation-lab/aws-bedrock-models-scraper.md - **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community) - **Categories:** AI - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing Pay per event This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. 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 ## AWS Bedrock Models Scraper ### What does AWS Bedrock Models Scraper do? **AWS Bedrock Models Scraper** extracts the complete catalog of foundation models available on [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-cards.html) — no AWS account, no API key, and no coding required. Run the actor and get structured data for every model including **provider name, model ID, context window size, supported modalities, model lifecycle status, launch date, EOL date, knowledge cutoff, and reasoning support**. The actor fetches AWS's official Bedrock documentation using lightweight HTTP requests with Cheerio-based HTML parsing. No browser automation, no Playwright, no proxies required. Every model is returned as a clean JSON record ready to export to CSV, Google Sheets, or any downstream pipeline. Use this actor to track all available Bedrock foundation models, monitor when new providers or models are added, compare model capabilities across providers, or automate catalog sync for AI platform selection tooling. --- ### Who is it for? **🤖 AWS developers and cloud architects** - Find the exact model ID needed for `InvokeModel` API calls without manually browsing docs - Verify context window sizes, supported modalities, and API endpoints before integrating - Automate checks for new model releases or lifecycle changes (Active → Deprecated) **📊 ML engineers and AI platform teams** - Compare capabilities across all Bedrock providers: Anthropic, Amazon, Meta, Mistral, Cohere, DeepSeek, and more - Track which models support reasoning, streaming, and tool calling - Build model selector tooling that stays current with the live Bedrock catalog **💰 FinOps and cost optimization teams** - Identify models with the largest context windows for long-document workflows - Track EOL dates to plan model migrations before deprecation - Compare reasoning-capable models across providers for agentic workload planning **🏢 Enterprise AI strategists** - Monitor when Amazon adds new providers or removes old ones from Bedrock - Track model lifecycle status changes across the full catalog - Build governance dashboards showing approved models and their availability status --- ### Why use AWS Bedrock Models Scraper? - **No AWS credentials required** — scrapes the public documentation page only - **Covers all providers** — AI21 Labs, Amazon Nova, Anthropic Claude, Cohere, DeepSeek, Google, Meta Llama, MiniMax, Mistral, Moonshot, NVIDIA, OpenAI, Qwen, Stability AI, TwelveLabs, Writer, Z.AI, and more - **Deep model details** — context window, max output tokens, input/output modalities, model ID, lifecycle status, launch date, EOL date, knowledge cutoff, and reasoning support - **Lightweight HTTP scraping** — no browser automation, no proxy required - **Pay-per-event pricing** — pay only for models extracted, not idle compute - **Schedule and automate** — run weekly to track catalog changes and new model additions - **Export anywhere** — JSON, CSV, Excel, Google Sheets, or push via API and webhook --- ### What data does it extract? | Field | Type | Description | |-------|------|-------------| | `provider` | string | Provider name (e.g. `Anthropic`, `Meta`, `Amazon`) | | `modelName` | string | Display name (e.g. `Claude Sonnet 4.6`, `Llama 3.3 70B Instruct`) | | `modelId` | string | API model ID for `InvokeModel` calls (e.g. `anthropic.claude-sonnet-4-6`) | | `contextWindow` | string | Maximum context window size (e.g. `1M tokens`, `128K tokens`) | | `maxOutputTokens` | string | Maximum output tokens per request (e.g. `64K`) | | `inputModalities` | string[] | Supported input types (e.g. `["Text", "Image"]`) | | `outputModalities` | string[] | Supported output types (e.g. `["Text"]`) | | `modelLifecycle` | string | Lifecycle status (`Active`, `Legacy`, etc.) | | `modelLaunchDate` | string | Date model became available (e.g. `Feb 17, 2026`) | | `modelEolDate` | string | End-of-life date or `N/A` if not scheduled | | `knowledgeCutoff` | string | Training data cutoff date (e.g. `Aug 2025`) | | `reasoningSupported` | boolean | Whether the model supports extended reasoning/thinking | | `modelCardUrl` | string | Direct URL to the AWS documentation model card | | `scrapedAt` | string | ISO timestamp of when data was collected | --- ### How much does it cost to scrape AWS Bedrock models? 🟢 **Very cheap.** The Bedrock catalog currently lists ~105 models across 16+ providers. At **$0.001 per model** (BRONZE tier), a full run costs approximately **$0.11** plus the **$0.005 start fee**. | Run type | Models | Mode | Estimated cost (BRONZE) | |----------|--------|------|-------------------------| | Catalog only (no detail pages) | ~105 models | `scrapeModelDetails: false` | ~$0.11 | | Full scrape with model details | ~105 models | `scrapeModelDetails: true` | ~$0.11 | | Weekly monitoring (52 runs/year) | ~105 models | Full | ~$5.75/year | | Daily monitoring (365 runs/year) | ~105 models | Full | ~$40/year | Higher Apify subscription tiers receive discounts (SILVER: $0.00078/model, GOLD: $0.0006/model, up to DIAMOND: $0.00028/model). All Apify platform compute costs are included. No proxy fees since the page is publicly accessible. --- ### How to use AWS Bedrock Models Scraper **Step 1:** Open the actor on [Apify Store](https://apify.com/automation-lab/aws-bedrock-models-scraper). **Step 2:** Click **Try for free** — no configuration needed. By default the actor scrapes all models and their detail pages. **Step 3:** Click **Start** and wait 1–3 minutes (detail page scraping fetches ~70 pages). **Step 4:** View results in the **Dataset** tab. Export to JSON, CSV, or Excel. **Step 5 (optional):** Disable `Scrape model details` for a faster catalog-only run (returns provider/name/URL only without individual model specs). **Step 6 (optional):** Schedule recurring runs in the **Schedules** tab to track catalog changes over time. --- ### Input parameters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `scrapeModelDetails` | boolean | `true` | Fetch each model's detail page for full specs (model ID, context window, modalities, lifecycle, etc.). Set to `false` for a fast catalog-only list. | | `maxRequestRetries` | integer | `3` | Number of retry attempts for failed HTTP requests | The actor requires no mandatory input. Clicking **Start** with defaults returns the full model catalog with all available details. --- ### Output example ```json { "provider": "Anthropic", "modelName": "Claude Sonnet 4.6", "modelCardUrl": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-anthropic-claude-sonnet-4-6.html", "modelId": "anthropic.claude-sonnet-4-6", "contextWindow": "1M tokens", "maxOutputTokens": "64K", "inputModalities": ["Image", "Text"], "outputModalities": ["Text"], "modelLifecycle": "Active", "modelLaunchDate": "Feb 17, 2026", "modelEolDate": "N/A", "knowledgeCutoff": "Aug 2025", "reasoningSupported": true, "scrapedAt": "2026-04-28T08:00:00.000Z" } ```` **Catalog-only mode example (scrapeModelDetails: false):** ```json { "provider": "Meta", "modelName": "Llama 3.3 70B Instruct", "modelCardUrl": "https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-meta-llama-3-3-70b-instruct.html", "modelId": null, "contextWindow": null, "maxOutputTokens": null, "inputModalities": [], "outputModalities": [], "modelLifecycle": null, "modelLaunchDate": null, "modelEolDate": null, "knowledgeCutoff": null, "reasoningSupported": null, "scrapedAt": "2026-04-28T08:00:00.000Z" } ``` *** ### Tips and best practices 💡 **Use catalog-only mode for fast lookups** — Set `scrapeModelDetails: false` to get the full provider/model name list with URLs in seconds. Ideal for deduplication checks or when you only need to know which models exist. 💡 **Schedule for catalog change detection** — AWS adds new models and providers to Bedrock frequently. Schedule weekly runs and compare datasets to detect new additions or lifecycle changes automatically. 💡 **Filter by `reasoningSupported: true` for agentic workloads** — Use this field to quickly identify models that support extended reasoning/thinking mode for complex multi-step tasks. 💡 **Use `modelId` directly in AWS SDK calls** — The extracted `modelId` (e.g. `anthropic.claude-sonnet-4-6`) is the value you pass to `InvokeModel` or `Converse` API calls without needing to navigate documentation. 💡 **Track `modelEolDate` for migration planning** — Monitor when models enter end-of-life to proactively migrate workloads. Null or "N/A" means no deprecation is scheduled yet. 💡 **Combine with pricing data** — AWS Bedrock pricing is on a separate page. Pair this catalog data with pricing lookups to build a full cost/capability comparison across providers. *** ### Integrations 🔄 **Zapier / Make.com** — Trigger downstream workflows when new providers or models appear. Connect Bedrock model data to Slack notifications, Airtable records, or Google Sheets automatically. 📊 **Google Sheets** — Export results directly to a Google Sheet for team-visible model catalogs and capability matrices. Use Apify's native Google Sheets integration or schedule the actor and auto-push results. 🤖 **Model selector tooling** — Feed model catalog data into your own AI platform selection tools. Use `modelId`, `contextWindow`, and `inputModalities` to power dynamic model pickers in internal apps. 🗄️ **Data pipelines** — Push results to PostgreSQL, BigQuery, or Snowflake via Apify webhooks for long-term catalog trend analysis and model lifecycle tracking. 📬 **Webhook notifications** — Set up Apify webhooks to POST results to your endpoint whenever a run completes, enabling real-time catalog sync in your infrastructure. *** ### API usage #### Node.js (Apify client) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const run = await client.actor('automation-lab/aws-bedrock-models-scraper').call({ scrapeModelDetails: true, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(`Extracted ${items.length} Bedrock models`); items.forEach(m => { console.log(`${m.provider} — ${m.modelName} (${m.modelId}): context ${m.contextWindow}`); }); ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("automation-lab/aws-bedrock-models-scraper").call(run_input={ "scrapeModelDetails": True }) items = client.dataset(run["defaultDatasetId"]).list_items().items print(f"Extracted {len(items)} Bedrock models") for m in items: print(f"{m['provider']} — {m['modelName']} ({m.get('modelId')}): context {m.get('contextWindow')}") ``` #### cURL ```bash ## Start the actor curl -X POST \ "https://api.apify.com/v2/acts/automation-lab~aws-bedrock-models-scraper/runs?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{"scrapeModelDetails": true}' ## Get results (replace DATASET_ID with the run's defaultDatasetId) curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN" ``` *** ### Use with Claude AI (MCP) You can use AWS Bedrock Models Scraper directly inside Claude via the [Apify MCP server](https://mcp.apify.com). #### Claude Code (terminal) ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/aws-bedrock-models-scraper" ``` #### Claude Desktop / Cursor / VS Code Add to your MCP config: ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com?tools=automation-lab/aws-bedrock-models-scraper", "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" } } } } ``` **Example prompts to use with Claude:** - *"Use the AWS Bedrock Models Scraper to list all models that support reasoning and have a context window over 100K tokens."* - *"Scrape the Bedrock catalog and show me all Anthropic Claude models currently in Active lifecycle."* - *"Run the Bedrock scraper and find all models with image input modality support."* *** ### Legality and terms of service This actor scrapes publicly accessible data from the AWS Bedrock documentation (`docs.aws.amazon.com`). The page is publicly accessible without authentication and contains no personal data — only product/model specifications. Scraping publicly available documentation for informational, research, and competitive intelligence purposes is generally accepted under fair use principles. Always review [AWS Terms of Service](https://aws.amazon.com/terms/) before using the data commercially. The actor does not log in, bypass access controls, or scrape any user-specific or private AWS data. *** ### FAQ **Q: How often should I run this actor to stay current?** A: AWS adds new models and providers to Bedrock every few weeks. A weekly schedule is sufficient for most use cases. Set up a schedule with email or webhook notifications to catch additions automatically. **Q: Why are some fields null?** A: When `scrapeModelDetails` is disabled, all detail fields are null (only catalog data is returned). With details enabled, a field may be null if AWS's documentation page doesn't include that information for a specific model (common for newer or preview models). **Q: How long does a full scrape take?** A: With `scrapeModelDetails: true`, the actor fetches ~70+ individual model card pages sequentially. Expect 1–3 minutes for a complete run depending on network latency. **Q: Can I scrape just one provider's models?** A: Not directly — the actor scrapes the full catalog. You can filter results after the run using the `provider` field to focus on a specific provider (e.g. filter where `provider === "Anthropic"`). **Q: The actor returned empty results or threw an error. What should I do?** A: AWS periodically updates their documentation structure. If the actor returns 0 items or throws an error about "No models found," please [open an issue](https://apify.com/automation-lab/aws-bedrock-models-scraper) in the actor's review section. You can also try increasing `maxRequestRetries` to 5 to handle transient network issues. **Q: Can I get a historical view of which models were available on a given date?** A: Yes — schedule recurring runs and each run's dataset includes the `scrapedAt` timestamp. Query across multiple dataset exports to build a timeline of catalog changes. *** ### Related scrapers - 🔗 [Groq Models Scraper](https://apify.com/automation-lab/groq-models-scraper) — All AI models on Groq with pricing and speed benchmarks - 🔗 [OpenRouter Models Scraper](https://apify.com/automation-lab/openrouter-models-scraper) — Full OpenRouter model catalog with pricing and capability metadata - 🔗 [Mistral Models Scraper](https://apify.com/automation-lab/mistral-models-scraper) — Mistral AI model catalog with pricing and context window data - 🔗 [Together AI Models Scraper](https://apify.com/automation-lab/together-ai-models-scraper) — Together AI model catalog with pricing and availability - 🔗 [DeepInfra Models Scraper](https://apify.com/automation-lab/deepinfra-models-scraper) — DeepInfra model catalog with pricing and throughput data # Actor input Schema ## `scrapeModelDetails` (type: `boolean`): If enabled, fetches each model's individual card page to extract additional specs: model ID, context window, max output tokens, input/output modalities, lifecycle status, launch date, EOL date, knowledge cutoff, and reasoning support. Disable to only return the provider/model name catalog from the main listing page (faster and cheaper). ## `maxRequestRetries` (type: `integer`): Number of retry attempts for failed HTTP requests before skipping a model. ## Actor input object example ```json { "scrapeModelDetails": true, "maxRequestRetries": 3 } ``` # Actor output Schema ## `overview` (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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "scrapeModelDetails": true, "maxRequestRetries": 3 }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/aws-bedrock-models-scraper").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 = { "scrapeModelDetails": True, "maxRequestRetries": 3, } # Run the Actor and wait for it to finish run = client.actor("automation-lab/aws-bedrock-models-scraper").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 '{ "scrapeModelDetails": true, "maxRequestRetries": 3 }' | apify call automation-lab/aws-bedrock-models-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=automation-lab/aws-bedrock-models-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "AWS Bedrock Models Scraper", "description": "Scrapes the full AWS Bedrock model catalog from the official AWS documentation. Returns all foundation models available on Amazon Bedrock with provider name, model name, model card URL, and optionally detailed specs from each model card page.", "version": "0.1", "x-build-id": "R0mFvfUxkdazmYGQD" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/automation-lab~aws-bedrock-models-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-automation-lab-aws-bedrock-models-scraper", "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/automation-lab~aws-bedrock-models-scraper/runs": { "post": { "operationId": "runs-sync-automation-lab-aws-bedrock-models-scraper", "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/automation-lab~aws-bedrock-models-scraper/run-sync": { "post": { "operationId": "run-sync-automation-lab-aws-bedrock-models-scraper", "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": { "scrapeModelDetails": { "title": "Scrape model details", "type": "boolean", "description": "If enabled, fetches each model's individual card page to extract additional specs: model ID, context window, max output tokens, input/output modalities, lifecycle status, launch date, EOL date, knowledge cutoff, and reasoning support. Disable to only return the provider/model name catalog from the main listing page (faster and cheaper).", "default": true }, "maxRequestRetries": { "title": "Max request retries", "minimum": 1, "maximum": 10, "type": "integer", "description": "Number of retry attempts for failed HTTP requests before skipping a model.", "default": 3 } } }, "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 } } } } } } } } } } ```