# SteamSpy Scraper — Game Sales, Owners & Analytics (`logiover/steamspy-scraper`) Actor Scrape SteamSpy by mode, genre, tag, or appId list. Extract game owners, sales estimates, CCU, playtime, ratings, and pricing for market research, competitive analysis, and game analytics. No API key, no login. - **URL**: https://apify.com/logiover/steamspy-scraper.md - **Developed by:** [Logiover](https://apify.com/logiover) (community) - **Categories:** Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 1,000 results 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/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 ## SteamSpy Scraper — Game Sales, Owners, Analytics & Market Data Extract Steam game ownership estimates, sales analytics, player counts, ratings, and playtime data from SteamSpy — no API key, no login required. --- ### What does SteamSpy Scraper do? SteamSpy Scraper connects directly to the public SteamSpy API (`steamspy.com/api.php`) and retrieves aggregated Steam game statistics for thousands of titles. It supports six scraping modes: top-100-all-time, top-100 in the last two weeks, full paginated catalog (`request=all`, ~1,000 games per page), genre-filtered lists, tag-filtered lists, and on-demand app-detail lookups by App ID. The engine uses `got-scraping` with optional Apify datacenter proxy. It respects SteamSpy's documented rate limits — one request per minute for paginated catalog pages, one request per second for individual app detail calls — to avoid being throttled. Pagination is fully automated: the `all` mode loops through pages until it either hits your `maxResults` cap or the API returns an empty page, meaning you can pull tens of thousands of games in a single run. All output is pushed directly to an Apify dataset in a clean, flat schema with numeric fields for owners, pricing, CCU, and reviews. --- ### Who is it for? - **Indie game developers** researching market positioning, pricing benchmarks, and genre saturation before launching a new title. - **Game analysts and journalists** who need ownership and revenue estimates for a specific game or a category of games. - **Investors and publishers** evaluating studios, tracking competitor performance, or building comparative dashboards. - **Data scientists and researchers** studying the Steam ecosystem, player behavior patterns, or genre trends over time. - **Business intelligence teams** integrating Steam market data into spreadsheets, BI tools, or automated reporting pipelines. --- ### Use cases - Pull the all-time top 1,000 most-owned games on Steam and analyze which genres dominate in owner count vs. review score. - Monitor weekly shifts in the top-100-in-2-weeks list to spot breakout titles and viral indie hits. - Benchmark your upcoming game's genre: extract all RPGs or all Roguelikes and compare average price, playtime, and review ratios. - Build a competitive intelligence spreadsheet by feeding a list of competitor App IDs to `appDetails` mode and exporting to CSV. - Create an automated weekly Slack alert via Apify schedules + webhooks whenever a new title enters the top-100 ownership chart. --- ### Why use SteamSpy Scraper? - **No API key, no login**: SteamSpy's public API is completely open — no credentials needed. - **19 data fields per game**: ownership estimates, pricing, discount, CCU, positive/negative reviews, playtime, genre, tags, and more. - **Bulk pagination**: `all` mode pulls up to tens of thousands of games across multiple pages; `appDetails` mode accepts unlimited App ID lists. - **Six flexible modes**: top-100-forever, top-100-in-2-weeks, full catalog, by genre, by tag, or by specific App IDs. - **Export-ready**: push to CSV, JSON, Excel, or Google Sheets with one click from the Apify Console. - **Pay-per-result pricing**: you only pay for what you actually scrape — ideal for occasional market research pulls. --- ### What data can you extract? SteamSpy Scraper returns one row per game containing all available analytics fields from the SteamSpy API: | Field | Type | Description | |---|---|---| | `appid` | string | Steam application ID | | `name` | string | Game title | | `developer` | string | Developer name(s) | | `publisher` | string | Publisher name(s) | | `ownersRange` | string | Estimated owner range (e.g. "2,000,000 .. 5,000,000") | | `ownersMin` | number | Lower bound of ownership estimate | | `ownersMax` | number | Upper bound of ownership estimate | | `priceUsd` | number | Current price in USD | | `initialPrice` | number | Original price before any discount (USD) | | `discount` | number | Current discount percentage (0–100) | | `ccu` | number | Peak concurrent user count (all-time) | | `positive` | number | Number of positive reviews | | `negative` | number | Number of negative reviews | | `positivePercent` | number | Percentage of positive reviews (0–100) | | `averagePlaytimeForever` | number | Average playtime in minutes (all players) | | `medianPlaytime` | number | Median playtime in minutes (all players) | | `genre` | string | Primary genre(s) | | `languages` | string | Supported languages | | `tags` | string | Comma-separated Steam community tags | #### Example output ```json { "appid": "730", "name": "Counter-Strike 2", "developer": "Valve", "publisher": "Valve", "ownersRange": "200,000,000 .. 500,000,000", "ownersMin": 200000000, "ownersMax": 500000000, "priceUsd": 0, "initialPrice": 0, "discount": 0, "ccu": 1818773, "positive": 4500000, "negative": 1200000, "positivePercent": 78.9, "averagePlaytimeForever": 13420, "medianPlaytime": 2400, "genre": "Action, Free to Play", "languages": "English, French, German, Spanish - Spain, ...", "tags": "FPS, Shooter, Multiplayer, Competitive, Action, First-Person, ..." } ```` *** ### How to use #### Option A — Top 100 lists (quickest start) Use this to get the top games ranked by all-time owners or recent popularity without any additional configuration. **Steps:** 1. Open the actor in Apify Console. 2. Set **Mode** to `top100forever` or `top100in2weeks`. 3. Click **Run** — results appear in seconds. **Input example:** ```json { "mode": "top100forever" } ``` #### Option B — Browse by genre or tag Use this to extract all games in a specific category for market research or competitive analysis. **Steps:** 1. Set **Mode** to `byGenre` or `byTag`. 2. Enter your target in the **Genre** or **Tag** field (e.g. `"Action"`, `"Roguelike"`). 3. Run — returns all games SteamSpy has for that category. **Input example:** ```json { "mode": "byGenre", "genre": "RPG" } ``` #### Option C — Specific App IDs Use this to pull detailed analytics for a list of known games — ideal for competitor research. **Input example:** ```json { "mode": "appDetails", "appIds": ["730", "570", "440", "271590", "1172470"] } ``` #### Option D — Full catalog pagination Use this to pull thousands of games ranked by owner count. Set `maxResults` to cap the output or `0` for unlimited. **Note:** SteamSpy rate-limits the `all` endpoint to 1 request per minute per page. The actor waits 62 seconds between pages automatically. With `maxResults=5000` (5 pages), expect ~5 minutes of run time. **Input example:** ```json { "mode": "all", "maxResults": 2000 } ``` *** ### Input parameters | Parameter | Type | Default | Description | |---|---|---|---| | `mode` | string | `"top100forever"` | Scraping mode. One of: `top100forever`, `top100in2weeks`, `all`, `byGenre`, `byTag`, `appDetails` | | `appIds` | array | `[]` | List of Steam App IDs (strings or numbers) — used with `mode=appDetails` | | `genre` | string | `""` | Genre to filter by (e.g. `"Action"`, `"Strategy"`) — used with `mode=byGenre` | | `tag` | string | `""` | Tag to filter by (e.g. `"Multiplayer"`, `"Open World"`) — used with `mode=byTag` | | `maxResults` | integer | `1000` | Maximum rows to return. Set `0` for unlimited. Only applies to `all` and `appDetails` modes. | | `proxy` | object | Apify datacenter | Proxy configuration. Defaults to Apify's shared datacenter proxies. | **Full input JSON:** ```json { "mode": "byTag", "tag": "Roguelike", "maxResults": 500, "proxy": { "useApifyProxy": true, "apifyProxyGroups": [] } } ``` *** ### Output example ```json { "appid": "1091500", "name": "Cyberpunk 2077", "developer": "CD PROJEKT RED", "publisher": "CD PROJEKT RED", "ownersRange": "20,000,000 .. 50,000,000", "ownersMin": 20000000, "ownersMax": 50000000, "priceUsd": 59.99, "initialPrice": 59.99, "discount": 0, "ccu": 238084, "positive": 620000, "negative": 135000, "positivePercent": 82.1, "averagePlaytimeForever": 3720, "medianPlaytime": 1560, "genre": "Action, RPG", "languages": "English, French, German, Polish, ...", "tags": "Cyberpunk, Open World, RPG, Action, Story Rich, Sci-fi, ..." } ``` *** ### Tips for best results - **For market research**: use `mode=top100forever` first to get a quick snapshot of dominant titles, then follow up with `byGenre` for niche deep-dives. - **For bulk catalog pulls**: set `maxResults=1000` (1 page) for quick runs; bump to `5000` for broader coverage, but expect proportionally longer wait times due to rate limits. - **For competitor tracking**: use `mode=appDetails` with a curated list of competitor App IDs — you can find IDs from a game's Steam URL (`store.steampowered.com/app/{APPID}/`). - **Ownership estimates**: SteamSpy provides ranges (e.g. "2,000,000 .. 5,000,000"), not exact counts. Use `ownersMin` and `ownersMax` for lower and upper bound analysis. - **CCU vs owners**: high CCU relative to owner count indicates strong retention and active playerbase — a key quality signal. - **Tags**: the `tags` field is the richest categorization signal on SteamSpy, sourced from community-voted tags. Filter by tag for more granular research than genre alone. - **Scheduling**: set up a weekly Apify schedule on `top100in2weeks` to track trending titles over time in a persistent dataset. - **Playtime signal**: `averagePlaytimeForever` near 0 for a paid game often signals high refund rates — a red flag when evaluating quality. - **Export to CSV**: click "Export" → "CSV" in the dataset view for instant spreadsheet-ready output. - **Combine with Steam Store API**: use `appid` values from SteamSpy results as inputs to other Steam scrapers for screenshots, descriptions, and review text. *** ### Integrations SteamSpy Scraper works with every Apify integration out of the box: - **Google Sheets**: use the Google Sheets integration in Apify Console to auto-sync results to a spreadsheet after each run. - **Slack**: configure a webhook to post a Slack message whenever the actor finishes — great for weekly top-100 alerts. - **Zapier / Make**: trigger downstream workflows (email reports, database inserts, Airtable updates) on run completion. - **Webhooks**: set `webhookUrl` in your run configuration to receive a POST payload with the run result and dataset URL. - **Scheduled runs**: use Apify's built-in Scheduler to auto-run every Monday at 08:00 UTC and keep your dataset fresh. *** ### API usage #### cURL ```bash curl -X POST \ "https://api.apify.com/v2/acts/logiover~steamspy-scraper/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"mode":"top100forever"}' ``` #### Node.js (Apify client) ```js import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); const run = await client.actor('logiover/steamspy-scraper').call({ mode: 'byGenre', genre: 'Action', maxResults: 500, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient(token="YOUR_API_TOKEN") run = client.actor("logiover/steamspy-scraper").call(run_input={ "mode": "byTag", "tag": "Roguelike", "maxResults": 200, }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["name"], item["ownersRange"], item["positivePercent"]) ``` *** ### Use with AI agents (MCP) SteamSpy Scraper is available as an MCP (Model Context Protocol) tool through Apify's MCP server. You can connect it to Claude, GPT-4, or any MCP-compatible AI agent and ask natural language questions like: *"Find all Roguelike games on Steam with more than 1 million owners and a positive review rate above 80%"* — the agent will call the scraper, receive the data, and reason over it automatically. Connect via `https://mcp.apify.com` and select this actor. *** ### FAQ #### Does this require an API key or login? No. SteamSpy's API is public and keyless. You don't need a SteamSpy account, a Steam API key, or any credentials to use this actor. #### How accurate are the ownership numbers? SteamSpy provides statistical estimates derived from Steam achievement data and purchase history modeling. Numbers are rounded to ranges (e.g. "2,000,000 .. 5,000,000") and are generally considered reliable for ballpark market research, though not officially endorsed by Valve. #### How many games can I scrape in one run? - `top100forever` and `top100in2weeks`: exactly 100 games per run. - `byGenre` and `byTag`: varies by category — typically 50–2,000 games depending on how populated the genre/tag is on SteamSpy. - `all` mode: up to tens of thousands across paginated pages. - `appDetails`: unlimited — as many App IDs as you provide. #### Why does `all` mode take so long? SteamSpy rate-limits the paginated catalog endpoint to 1 request per minute per page. The actor respects this and waits 62 seconds between pages. For 5,000 games (5 pages), expect ~5 minutes; for 10,000 games, ~10 minutes. #### Why are some fields null or empty? Not all games have complete data on SteamSpy. Niche titles, very old games, or recently released games may have missing genre, language, or pricing data. The actor always pushes whatever is available and leaves unset fields as `null`. #### How do I export results to Excel? In the Apify Console, open the run's Dataset tab, click **Export** → **XLSX** for Excel format, or **CSV** for spreadsheets. #### Can I run multiple App ID lookups efficiently? Yes. Use `mode=appDetails` and pass all your App IDs in the `appIds` array. The actor fetches them sequentially with a 1.1-second delay between each to respect SteamSpy's rate limit. #### Is there a way to get data for a specific Steam tag? Yes — use `mode=byTag` and set the `tag` field to any Steam community tag string (e.g. `"Battle Royale"`, `"Pixel Graphics"`, `"Tower Defense"`). Tag names must match SteamSpy's internal naming exactly. #### How often is SteamSpy data updated? SteamSpy refreshes its data approximately every 24 hours. Running this actor more than once per day will yield the same data; weekly or bi-weekly runs are sufficient for trend monitoring. #### Is this related to the Steam API? No. This actor uses the SteamSpy API (`steamspy.com/api.php`), which is a separate third-party service that aggregates and estimates Steam game statistics. It does not call Valve's official Steam Web API. #### What's the difference between averagePlaytimeForever and medianPlaytime? `averagePlaytimeForever` is the arithmetic mean of all recorded playtime (in minutes) across all players. `medianPlaytime` is the midpoint value — 50% of players have played more than this, 50% less. The median is often more useful because it's not skewed by extreme outliers (players with tens of thousands of hours). #### Are there related scrapers I can combine this with? Yes — combine SteamSpy Scraper output (which gives you `appid` values) with Steam Store scrapers for descriptions and screenshots, or use it alongside the logiover LinkedIn Company Scraper and B2B Lead Scraper for research on game studio teams. *** ### Is it legal? SteamSpy Scraper accesses only the publicly available SteamSpy API, which is freely accessible to everyone without any authentication. The data returned is aggregated, anonymized, and does not include any personally identifiable information. This actor is intended for legitimate market research, competitive analysis, and business intelligence purposes. Users are responsible for ensuring their use of the extracted data complies with SteamSpy's Terms of Service and applicable data protection regulations. Scraping publicly available APIs for non-commercial research is generally considered lawful in most jurisdictions. *** ### Related scrapers - **B2B Lead Scraper** (`logiover/b2b-lead-scraper`) — find contact data for game studios and publishers using OpenStreetMap data. - **LinkedIn Company Scraper** (`logiover/linkedin-company-scraper`) — look up studio headcount, funding rounds, and job postings. - **Tech Stack Detector** (`logiover/tech-stack-detector`) — identify the tech infrastructure behind a game developer's website. - **GitHub Activity Scraper** (`logiover/github-activity-scraper`) — monitor open-source game engine repos and developer contributions. # Actor input Schema ## `mode` (type: `string`): What to fetch. 'top100forever' = all-time top 100 by owners (default), 'top100in2weeks' = top 100 by recent players, 'all' = paginate every game ranked by owners, 'byGenre' = games in a genre, 'byTag' = games with a tag, 'appDetails' = specific Steam App IDs. ## `genre` (type: `string`): Steam store genre to filter by (used with mode = By genre). ## `tag` (type: `string`): Steam user tag to filter by (used with mode = By tag). Any Steam tag works, e.g. 'Multiplayer', 'Open World', 'Roguelike', 'Survival', 'Souls-like'. ## `appIds` (type: `array`): List of Steam App IDs to fetch details for (used with mode = App details). Example: \[730, 570, 440]. ## `maxResults` (type: `integer`): Maximum number of results to return. Mainly caps 'all' mode (each page ≈ 1000 games). Set 0 for unlimited. Top-100 modes return up to 100. ## `proxy` (type: `object`): Apify proxy configuration. Defaults to Apify Proxy (automatic). The actor also falls back to a direct connection on the final retry, so a proxy is optional for this public API. ## Actor input object example ```json { "mode": "top100forever", "genre": "", "maxResults": 1000, "proxy": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel. # 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 = { "proxy": { "useApifyProxy": true } }; // Run the Actor and wait for it to finish const run = await client.actor("logiover/steamspy-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 = { "proxy": { "useApifyProxy": True } } # Run the Actor and wait for it to finish run = client.actor("logiover/steamspy-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 '{ "proxy": { "useApifyProxy": true } }' | apify call logiover/steamspy-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=logiover/steamspy-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "SteamSpy Scraper — Game Sales, Owners & Analytics", "description": "Scrape SteamSpy by mode, genre, tag, or appId list. Extract game owners, sales estimates, CCU, playtime, ratings, and pricing for market research, competitive analysis, and game analytics. No API key, no login.", "version": "1.0", "x-build-id": "meV4gZSQUaWTpNh25" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/logiover~steamspy-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-logiover-steamspy-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/logiover~steamspy-scraper/runs": { "post": { "operationId": "runs-sync-logiover-steamspy-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/logiover~steamspy-scraper/run-sync": { "post": { "operationId": "run-sync-logiover-steamspy-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": { "mode": { "title": "Mode", "enum": [ "top100forever", "top100in2weeks", "all", "byGenre", "byTag", "appDetails" ], "type": "string", "description": "What to fetch. 'top100forever' = all-time top 100 by owners (default), 'top100in2weeks' = top 100 by recent players, 'all' = paginate every game ranked by owners, 'byGenre' = games in a genre, 'byTag' = games with a tag, 'appDetails' = specific Steam App IDs.", "default": "top100forever" }, "genre": { "title": "Genre", "enum": [ "", "Action", "Adventure", "Casual", "Indie", "Massively Multiplayer", "Racing", "RPG", "Simulation", "Sports", "Strategy", "Free to Play", "Early Access" ], "type": "string", "description": "Steam store genre to filter by (used with mode = By genre).", "default": "" }, "tag": { "title": "Tag", "type": "string", "description": "Steam user tag to filter by (used with mode = By tag). Any Steam tag works, e.g. 'Multiplayer', 'Open World', 'Roguelike', 'Survival', 'Souls-like'." }, "appIds": { "title": "App IDs", "type": "array", "description": "List of Steam App IDs to fetch details for (used with mode = App details). Example: [730, 570, 440].", "items": { "type": "string" } }, "maxResults": { "title": "Max Results", "minimum": 0, "type": "integer", "description": "Maximum number of results to return. Mainly caps 'all' mode (each page ≈ 1000 games). Set 0 for unlimited. Top-100 modes return up to 100.", "default": 1000 }, "proxy": { "title": "Proxy Configuration", "type": "object", "description": "Apify proxy configuration. Defaults to Apify Proxy (automatic). The actor also falls back to a direct connection on the final retry, so a proxy is optional for this public API." } } }, "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 } } } } } } } } } } ```