# OpenRouter Model Scraper (`datapilot/openrouter-model-scraper`) Actor OpenRouter Models Scraper extracts AI model metadata from OpenRouter API, including pricing, context length, providers, modalities, token limits, vision/tool support, JSON support, and model architecture. Supports keyword filtering, proxy rotation, and structured dataset - **URL**: https://apify.com/datapilot/openrouter-model-scraper.md - **Developed by:** [Data Pilot](https://apify.com/datapilot) (community) - **Categories:** AI - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing from $4.50 / 1,000 scraped results This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. 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 ## Open Router Model Scraper 🤖 **Open Router Model Scraper** is a powerful Apify Actor designed to discover and analyze comprehensive **Open Router Model** data from the OpenRouter API. This tool provides detailed **Open Router Model** information including pricing, capabilities, context lengths, and architectural details. Whether you're researching AI models, comparing **Open Router Model** costs, or building AI applications, the Open Router Model Scraper delivers detailed **Open Router Model** intelligence efficiently. With direct OpenRouter API integration, multi-keyword filtering, comprehensive field extraction, and pricing calculation, the Open Router Model Scraper ensures complete discovery of relevant **Open Router Model** options. It focuses on key **Open Router Model** metrics including pricing, context length, vision support, tool calling, and JSON output capabilities, making it an essential tool for **Open Router Model** research and AI application development. --- ### 📋 Table of Contents - [Features](#-features) - [Data Source](#-data-source) - [How It Works](#-how-it-works) - [Input](#-input) - [Output](#-output) - [Technical Stack](#-technical-stack) - [Data Fields](#-data-fields) - [Model Capabilities](#-model-capabilities) - [Use Cases](#-use-cases) - [Quick Start](#-quick-start) - [Configuration](#-configuration) - [Performance](#-performance) - [Important Notes](#-important-notes) - [Keywords](#-keywords) - [Changelog](#-changelog) - [Support](#-support) --- ### 🔥 Features - **OpenRouter API Integration** – Direct integration with OpenRouter to access 200+ **Open Router Model** options. - **Multi-Keyword Search** – Filter **Open Router Model** by provider, name, or capabilities using multiple keywords (up to 10). - **Comprehensive Model Data** – Extracts 20+ fields including pricing, context length, and capabilities. - **Pricing Calculation** – Converts pricing from API format to human-readable per-million-token rates. - **Vision Support Detection** – Identifies **Open Router Model** with image/vision capabilities. - **Tool Calling Support** – Detects models supporting function calling and tool use. - **JSON Output Support** – Identifies models with JSON output capabilities. - **Context Length Tracking** – Includes maximum context window information. - **Token Limits** – Captures maximum prompt, completion, and response token limits. - **Architecture Information** – Extracts model architecture, tokenizer, and instruction type. - **Moderation Status** – Indicates if **Open Router Model** includes safety moderation. - **Multi-Provider Support** – Covers models from OpenAI, Anthropic, Cohere, Meta, and more. - **Date Tracking** – Records model creation date for version tracking. - **Direct Links** – Generates direct OpenRouter links to each **Open Router Model**. - **Proxy Support** – Apify residential proxy support for reliable API access. - **Bulk Model Processing** – Discovers and analyzes multiple **Open Router Model** simultaneously. - **Real-Time Dataset Push** – Pushes results to Apify Dataset with metadata. - **Timestamp Recording** – Records scrape timestamp for audit trails. --- ### 🌍 Data Source #### **OpenRouter API** - **Authority**: OpenRouter.ai - AI model aggregation platform - **Coverage**: 200+ AI models from multiple providers - **Data Quality**: Official, real-time pricing and model data - **API**: REST API v1 - **Endpoint**: `https://openrouter.ai/api/v1/models` - **Authentication**: No authentication required for public data - **Response Format**: JSON - **Rate Limits**: Reasonable rate limits for research use - **Completeness**: Includes LLMs, vision models, and specialized models --- ### ⚙️ How It Works The Open Router Model Scraper connects to the OpenRouter API and retrieves the complete catalog of available **Open Router Model** options. It filters results based on optional keywords, extracts comprehensive model metadata, calculates pricing information, and detects model capabilities. Results are pushed to the Apify Dataset with complete information. **Key Processing Steps:** 1. **Input Parsing** – Accept keywords and configuration from Actor input 2. **Proxy Setup** – Configure Apify residential proxy if available 3. **API Connection** – Connect to OpenRouter API with proper headers 4. **Model Fetch** – Retrieve complete catalog of **Open Router Model** options 5. **Keyword Filtering** – Filter models based on provided keywords 6. **Model Parsing** – Extract comprehensive metadata from each model 7. **Pricing Calculation** – Convert pricing from API format to readable rates 8. **Capability Detection** – Identify vision, tools, and JSON capabilities 9. **Date Formatting** – Parse and format creation dates 10. **Result Compilation** – Aggregate all model information 11. **Dataset Push** – Push individual model records to Apify Dataset 12. **Progress Logging** – Report processing statistics **Key Benefits:** - Discover all available **Open Router Model** options - Compare **Open Router Model** pricing across providers - Identify models with specific capabilities - Research **Open Router Model** architecture and specifications - Find cost-effective **Open Router Model** alternatives - Plan AI application development with accurate pricing - Track **Open Router Model** updates and releases --- ### 📥 Input The Actor accepts the following input parameters: | Field | Type | Default | Description | |-------|------|---------|-------------| | `keywords` | string | "all" | Comma-separated keywords to filter **Open Router Model** (max 10). Use "all" for complete catalog. Examples: "gpt,claude,vision" | | `useApifyProxy` | boolean | `true` | Enable Apify residential proxies for API access | | `apifyProxyGroups` | array | `["RESIDENTIAL"]` | Proxy group configuration | **Example Input:** ```json { "keywords": "claude,vision", "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } ```` **All Models Example:** ```json { "keywords": "all", "useApifyProxy": true } ``` **Multi-Keyword Example:** ```json { "keywords": "gpt-4,claude-3,vision,multimodal", "useApifyProxy": true } ``` *** ### 📤 Output The Actor pushes **Open Router Model** records with the following structure: | Field | Type | Description | |-------|------|-------------| | `keyword` | string | Search keyword used to find this model | | `model_id` | string | Full model identifier (provider/model-name) | | `provider` | string | Model provider (OpenAI, Anthropic, etc.) | | `model_name` | string | Model name without provider prefix | | `display_name` | string | Human-readable model display name | | `description` | string | Model description (300 chars max) | | `created_date` | string | Model creation/release date (YYYY-MM-DD) | | `context_length` | integer | Maximum context window size | | `max_completion_tokens` | integer | Max completion tokens | | `max_prompt_tokens` | integer | Max prompt tokens | | `max_response_tokens` | integer | Max response tokens | | `price_per_1m_input` | string | Input token pricing per million tokens | | `price_per_1m_output` | string | Output token pricing per million tokens | | `price_per_image` | string | Image processing pricing | | `price_per_request` | string | Per-request pricing (if applicable) | | `modality` | string | Model type (text, text+vision, etc.) | | `tokenizer` | string | Tokenizer type used | | `instruct_type` | string | Instruction following format | | `supports_vision` | string | Vision/image capability (yes/no) | | `supports_tools` | string | Function calling/tool support (yes/no) | | `supports_json_output` | string | JSON output capability (yes/no) | | `is_moderated` | string | Safety moderation status | | `openrouter_url` | string | Direct link to model on OpenRouter | | `scraped_at` | string | ISO 8601 scrape timestamp | **Example Output Record (Claude):** ```json { "keyword": "claude", "model_id": "anthropic/claude-3-opus", "provider": "anthropic", "model_name": "claude-3-opus", "display_name": "Claude 3 Opus", "description": "Most powerful Claude model, best for complex tasks requiring nuance, creativity, and reasoning.", "created_date": "2024-02-29", "context_length": 200000, "max_completion_tokens": 4096, "max_prompt_tokens": 200000, "max_response_tokens": 4096, "price_per_1m_input": "$0.0150", "price_per_1m_output": "$0.0750", "price_per_image": "", "price_per_request": "", "modality": "text", "tokenizer": "claude", "instruct_type": "chat", "supports_vision": "yes", "supports_tools": "yes", "supports_json_output": "yes", "is_moderated": "True", "openrouter_url": "https://openrouter.ai/anthropic/claude-3-opus", "scraped_at": "2025-02-14T12:00:00Z" } ``` **Example Output Record (Vision Model):** ```json { "keyword": "vision", "model_id": "openai/gpt-4-vision-preview", "provider": "openai", "model_name": "gpt-4-vision-preview", "display_name": "GPT-4 Vision", "description": "Multimodal model supporting image inputs alongside text for comprehensive understanding.", "created_date": "2024-01-15", "context_length": 128000, "max_completion_tokens": 4096, "max_prompt_tokens": 128000, "max_response_tokens": 4096, "price_per_1m_input": "$0.0100", "price_per_1m_output": "$0.0300", "price_per_image": "$0.0086", "price_per_request": "", "modality": "text+vision", "tokenizer": "cl100k_base", "instruct_type": "chat", "supports_vision": "yes", "supports_tools": "yes", "supports_json_output": "yes", "is_moderated": "True", "openrouter_url": "https://openrouter.ai/openai/gpt-4-vision-preview", "scraped_at": "2025-02-14T12:00:00Z" } ``` *** ### 🧰 Technical Stack - **HTTP Requests:** requests library with session management - **API:** OpenRouter REST API v1 (JSON) - **Async:** asyncio for concurrent operations - **JSON:** Native JSON parsing - **Proxy:** Apify Proxy with residential support - **Logging:** Apify Actor logging system - **Platform:** Apify Actor serverless environment - **Timeout:** 15 seconds per API request *** ### 📊 Data Fields Explained #### **Model Identification** - **model\_id**: Unique identifier (provider/model-name) - **provider**: Model provider (OpenAI, Anthropic, etc.) - **model\_name**: Model name without provider - **display\_name**: Human-readable name #### **Capabilities** - **context\_length**: Maximum context window - **supports\_vision**: Image/vision processing capability - **supports\_tools**: Function calling support - **supports\_json\_output**: JSON-mode output capability - **modality**: Model type (text, text+vision, audio, etc.) #### **Token Limits** - **max\_completion\_tokens**: Maximum response tokens - **max\_prompt\_tokens**: Maximum input tokens - **max\_response\_tokens**: Maximum response length #### **Pricing** - **price\_per\_1m\_input**: Per-million-token input cost - **price\_per\_1m\_output**: Per-million-token output cost - **price\_per\_image**: Image processing cost - **price\_per\_request**: Fixed per-request cost #### **Technical Details** - **tokenizer**: Tokenization method - **instruct\_type**: Instruction format (chat, completion, etc.) - **modality**: Model type - **is\_moderated**: Safety moderation applied #### **Metadata** - **created\_date**: Model release date - **description**: Model overview - **openrouter\_url**: Direct OpenRouter link - **scraped\_at**: Data retrieval timestamp *** ### 🎯 Model Capabilities #### **Vision Support** Models with image/vision input capabilities: - GPT-4 Vision - Claude 3 (all variants) - LLaVA models - Llama 2 Vision #### **Tool Calling** Models supporting function calling: - GPT-4 (all variants) - Claude 3 (all variants) - Llama 2 - Mistral #### **JSON Output** Models with JSON-mode: - GPT-4 (all) - Claude 3 (all) - Llama 2 - Mistral *** ### 🎯 Use Cases - **AI Model Research** – Research available **Open Router Model** options - **Cost Comparison** – Compare **Open Router Model** pricing across providers - **Application Selection** – Find optimal **Open Router Model** for specific needs - **Capability Discovery** – Identify models with required features - **Pricing Analysis** – Analyze **Open Router Model** cost structures - **Provider Evaluation** – Compare different providers' **Open Router Model** offerings - **Performance Planning** – Select models based on context length and token limits - **Feature Requirements** – Find models supporting vision, tools, or JSON - **Budget Planning** – Estimate costs using **Open Router Model** pricing data - **Competitive Analysis** – Track competing AI models on OpenRouter - **AI Stack Selection** – Choose models for multi-model AI applications - **Testing Alternatives** – Find alternative **Open Router Model** for testing - **Vendor Comparison** – Compare OpenAI, Anthropic, Cohere, etc. - **Model Benchmarking** – Compare model specifications and capabilities - **Pricing Alerts** – Monitor **Open Router Model** pricing changes *** ### 🚀 Quick Start #### **1. Prepare Input** Go to Apify Console and enter: ```json { "keywords": "claude,gpt-4,vision", "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] } ``` #### **2. Run the Actor** Click **Start** button. The Actor will: - Connect to OpenRouter API - Filter models by keywords - Extract comprehensive model data - Parse pricing information - Detect capabilities - Push results to Dataset #### **3. Monitor Progress** Console shows: ``` Keywords (3): claude,gpt-4,vision Proxy active: ['RESIDENTIAL'] Total models on OpenRouter: 287 Keyword 'claude' → 12 models matched Pushed 12 records for 'claude' Keyword 'gpt-4' → 8 models matched Pushed 8 records for 'gpt-4' Keyword 'vision' → 15 models matched Pushed 15 records for 'vision' Done! 3 keyword(s), 35 total records pushed. ``` #### **4. View & Download Results** - **Results Tab**: All model records - **Export**: JSON, CSV, Excel - **Filter**: By provider or capability - **Sort**: By pricing or context length *** ### 📈 Performance #### **Processing Speed** - \~2-5 seconds for single API fetch - \~10-30 seconds for parsing and pushing 200+ models - Includes keyword filtering and capability detection #### **Resource Usage** - Memory: ~50-80MB - CPU: ~10-15% during processing - Network: ~500KB-2MB per full scan - API calls: 1 (single request to fetch all models) #### **Scalability** - Handles 200+ models efficiently - Real-time Dataset push - No pagination needed (API provides all models in single response) *** ### ⚠️ Important Notes #### **Legal & Compliance** - **Fair Use**: Data collection respects OpenRouter terms - **Public Data**: All data from public OpenRouter API - **Attribution**: OpenRouter provides all model data - **Pricing**: Subject to change; verify with OpenRouter for current rates - **Terms of Service**: Complies with OpenRouter ToS #### **Data Quality** - **Accuracy**: Reflects OpenRouter's live catalog - **Currency**: Pricing updated by OpenRouter - **Completeness**: Includes all models in OpenRouter catalog - **Freshness**: Real-time data from API - **Verification**: Always verify pricing on OpenRouter #### **Best Practices** - Verify pricing before integration - Check context length requirements - Test model capabilities for your use case - Monitor for model updates - Compare with latest OpenRouter data - Consider model performance/cost tradeoffs *** *** ### 📦 Changelog **Initial Release:** - OpenRouter API v1 integration - Complete **Open Router Model** catalog fetching - Multi-keyword filtering (up to 10 keywords) - Comprehensive metadata extraction (20+ fields) - Pricing calculation and formatting - Vision support detection - Tool calling capability detection - JSON output support identification - Context length tracking - Token limit extraction - Model architecture information - Moderation status detection - Date parsing and formatting - Direct URL generation - Apify proxy support - Bulk model processing - Real-time Dataset push - ISO 8601 timestamp recording - Error handling and logging - Asyncio executor for non-blocking requests *** ### 🧑‍💻 Support & Feedback - **Issues:** Submit via Apify console - **Documentation:** Check Actor details page - **Community:** Apify forum discussions - **Feature Requests:** Suggest improvements - **Bug Reports:** Include keywords and errors #### **Output Access** - **Results Tab**: All model records - **Export**: JSON, CSV, Excel - **Filter**: By provider or capability - **API**: Query via Apify API *** ### 📄 License & Legal **Terms of Use:** - Use for legitimate AI research and development - Respect OpenRouter terms of service - Verify pricing before integration - Don't republish without attribution - Comply with applicable laws - Use data ethically and responsibly **Disclaimer:** Open Router Model Scraper is provided as-is for research purposes. Users are responsible for ensuring compliance with OpenRouter ToS. Always verify model data and pricing with official OpenRouter sources. *** ### 🎉 Get Started Today **Deploy now for AI model research!** Use for: - 🤖 Model Research - 💰 Pricing Analysis - 🔍 Capability Discovery - 📊 Provider Comparison - 🚀 Application Selection **Perfect for:** - AI Developers - ML Engineers - Product Managers - AI Researchers - Startup Founders *** **Last Updated:** February 2025\ **Version:** 1.0.0\ **Status:** Production Ready\ **Platform:** Apify Actor\ **Architecture:** Async/Await\ **API Source:** OpenRouter v1\ **Models Tracked:** 200+\ **Data Quality:** Real-time *** ### 📚 Related Tools - Smart Article Extractor - Skill Curator Scraper - Website Technology Stack Scraper - Google Keyword Finder **Your complete Apify-powered AI model discovery solution!** 🚀✨ *** ### 🤖 AI Model Excellence This Actor is optimized for **Open Router Model** discovery with: - ✅ Complete OpenRouter API integration - ✅ Multi-keyword filtering - ✅ Comprehensive field extraction - ✅ Pricing calculation - ✅ Capability detection - ✅ Real-time Dataset integration - ✅ Error recovery - ✅ Production-ready code **Discover AI models effortlessly!** 💎🚀 # Actor input Schema ## `keywords` (type: `string`): Filter keywords — e.g. 'gpt, claude, gemini, free, vision'. Use 'all' to get every model. Max 10 keywords. ## `useApifyProxy` (type: `boolean`): Enable residential proxy to avoid rate limiting. ## `apifyProxyGroups` (type: `array`): RESIDENTIAL recommended. ## Actor input object example ```json { "keywords": "gpt, claude, gemini, mistral, llama, free, vision, anthropic, openai, all", "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } ``` # 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 = { "keywords": "gpt, claude, gemini, mistral, llama, free, vision, anthropic, openai, all" }; // Run the Actor and wait for it to finish const run = await client.actor("datapilot/openrouter-model-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 = { "keywords": "gpt, claude, gemini, mistral, llama, free, vision, anthropic, openai, all" } # Run the Actor and wait for it to finish run = client.actor("datapilot/openrouter-model-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 '{ "keywords": "gpt, claude, gemini, mistral, llama, free, vision, anthropic, openai, all" }' | apify call datapilot/openrouter-model-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=datapilot/openrouter-model-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "OpenRouter Model Scraper", "description": "OpenRouter Models Scraper extracts AI model metadata from OpenRouter API, including pricing, context length, providers, modalities, token limits, vision/tool support, JSON support, and model architecture. Supports keyword filtering, proxy rotation, and structured dataset", "version": "0.0", "x-build-id": "anUKjXAvnu3x1WKHj" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/datapilot~openrouter-model-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-datapilot-openrouter-model-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/datapilot~openrouter-model-scraper/runs": { "post": { "operationId": "runs-sync-datapilot-openrouter-model-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/datapilot~openrouter-model-scraper/run-sync": { "post": { "operationId": "run-sync-datapilot-openrouter-model-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", "required": [ "keywords" ], "properties": { "keywords": { "title": "Keywords (up to 10, comma-separated)", "type": "string", "description": "Filter keywords — e.g. 'gpt, claude, gemini, free, vision'. Use 'all' to get every model. Max 10 keywords." }, "useApifyProxy": { "title": "Use Apify Proxy", "type": "boolean", "description": "Enable residential proxy to avoid rate limiting.", "default": true }, "apifyProxyGroups": { "title": "Proxy Group", "uniqueItems": true, "type": "array", "description": "RESIDENTIAL recommended.", "items": { "type": "string", "enum": [ "RESIDENTIAL", "DATACENTER", "GOOGLE" ] }, "default": [ "RESIDENTIAL" ] } } }, "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 } } } } } } } } } } ```