# Spotify Track Play Count Scraper (`automation-lab/spotify-track-play-count-scraper`) Actor 🎵 Get exact Spotify track stream counts from public artist, album, and track URLs. Export timestamped rows for release velocity, catalog analysis, and scheduled monitoring—no Spotify API key or login. - **URL**: https://apify.com/automation-lab/spotify-track-play-count-scraper.md - **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community) - **Categories:** Social media - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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/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 ## Spotify Track Play Count Scraper Extract **exact cumulative Spotify play counts** from public artist, album, and track URLs. Spotify Track Play Count Scraper turns each track into a clean, timestamped row for stream monitoring, release analysis, catalog reporting, and scheduled snapshots—without a Spotify developer key or account login. Paste a Spotify URL, run the Actor, and export the result as JSON, CSV, Excel, XML, or HTML. - 🎵 Exact per-track `playCount`, not an estimate - 💿 Artist, album, and individual track URL support - ⏱️ One `observedAt` timestamp for each run snapshot - 🧭 Track, album, and artist IDs plus canonical links - 🔐 Public data workflow with no user credentials - 🔁 Deduplicated output ready for daily or weekly monitoring ### What does Spotify Track Play Count Scraper do? The Actor reads public Spotify catalog URLs and emits one dataset row per track. For an **album URL**, it returns the album's track list and exact count for every track. For a **track URL**, it resolves the track's album context and returns only the requested track. For an **artist URL**, it expands a bounded number of recent albums and optional singles, then returns their track counts. Every result includes the IDs and names needed to match the same track in a later run. That makes the output suitable for stream-delta calculations rather than one-off visual inspection. ### Who is this Spotify stream count extractor for? #### Record labels and distributors - 📈 Compare release velocity across singles and albums. - 🗓️ Schedule daily snapshots for launch-week reporting. - 🧾 Join Spotify IDs to internal catalog or royalty systems. #### Artists and managers - 🎤 Track how a new release grows between checkpoints. - 💡 Find catalog tracks that accelerate after campaigns or placements. - 📊 Build simple progress dashboards without manual copying. #### Music marketers - 📣 Measure count movement around ads, influencer campaigns, and press. - 🔎 Compare the response of several promoted tracks. - 🧪 Export repeatable observations for campaign attribution analysis. #### Chart, royalty, and catalog analysts - 🧮 Compute stream deltas from exact cumulative observations. - 🧩 Match records by stable Spotify track and artist IDs. - 🏷️ Retain content rating, duration, ordering, and playability context. ### Why use this Actor? Spotify's official Web API provides rich catalog metadata but does not expose the exact cumulative play count shown by Spotify's own public client surfaces. This Actor focuses on that missing metric. It avoids estimates, popularity-score conversions, and fabricated counts. If Spotify stops returning a numeric count or changes its public response shape, the Actor reports a clear extraction failure instead of silently guessing. Other practical benefits include: - ⚡ HTTP-first execution with low memory requirements - 🔁 Bounded artist expansion for predictable runs - 🧹 Global track deduplication across overlapping inputs - 🧰 Standard Apify API, schedules, webhooks, and integrations - 📦 Consistent flat records for BI tools and spreadsheets ### What Spotify data can I extract? | Field | Type | Description | |---|---|---| | `sourceType` | string | Input entity type: `artist`, `album`, or `track` | | `sourceUrl` | string | Canonical input Spotify URL | | `albumId` | string | Spotify album ID | | `albumName` | string | Album or release name | | `albumUrl` | string | Canonical Spotify album URL | | `trackId` | string | Stable Spotify track ID | | `trackName` | string | Track title | | `trackUrl` | string | Canonical Spotify track URL | | `primaryArtistId` | string | First credited artist ID | | `primaryArtistName` | string | First credited artist name | | `artistIds` | array | IDs of all credited artists | | `artistNames` | array | Names of all credited artists | | `playCount` | number | Exact cumulative play count observed | | `discNumber` | number | Disc position | | `trackNumber` | number | Track position on the disc | | `durationMs` | number | Duration in milliseconds | | `contentRating` | string | Spotify content label, such as `EXPLICIT` or `NONE` | | `isExplicit` | boolean | Convenient explicit-content flag | | `isPlayable` | boolean | Whether Spotify marks the track playable | | `observedAt` | string | UTC ISO timestamp of the snapshot | ### How to scrape Spotify play counts 1. Open the Actor input page. 2. Add one or more public Spotify artist, album, or track URLs. 3. Keep `maxTracks` low for the first run. 4. For artist URLs, select how many recent releases to inspect. 5. Choose whether to include singles. 6. Click **Start**. 7. Review the **Track play counts** dataset view. 8. Export the dataset or connect a webhook, API client, or integration. A small album normally completes in seconds. Large artist snapshots take longer because each selected release is inspected separately. ### Input parameters #### `spotifyUrls` Required list of 1–20 URLs from `open.spotify.com`. Supported examples: ```text https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm https://open.spotify.com/artist/1Xyo4u8uXC1ZmMpatF05PJ https://open.spotify.com/track/7MXVkk9YMctZqd1Srtv4MB ```` Playlist, episode, show, user, shortened, and non-Spotify URLs are rejected. #### `maxTracks` Global cap on unique output rows. Default: `100`. Use `20` for a cheap first album test and raise it for catalogs. #### `maxAlbumsPerArtist` Maximum recent album/single releases inspected for each artist URL. Default: `3`; maximum: `20`. #### `includeSingles` When enabled, artist expansion includes singles as well as albums. Default: `true`. ### Input example ```json { "spotifyUrls": [ "https://open.spotify.com/artist/1Xyo4u8uXC1ZmMpatF05PJ" ], "maxAlbumsPerArtist": 3, "includeSingles": true, "maxTracks": 50 } ``` For one exact track lookup: ```json { "spotifyUrls": [ "https://open.spotify.com/track/7MXVkk9YMctZqd1Srtv4MB" ], "maxTracks": 1 } ``` ### Output example ```json { "sourceType": "album", "sourceUrl": "https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm", "albumId": "1XkGORuUX2QGOEIL4EbJKm", "albumName": "Favourite Worst Nightmare", "albumUrl": "https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm", "trackId": "7f9I5WdyXm5q1XqnSYgQZb", "trackName": "Brianstorm", "trackUrl": "https://open.spotify.com/track/7f9I5WdyXm5q1XqnSYgQZb", "primaryArtistId": "7Ln80lUS6He07XvHI8qqHH", "primaryArtistName": "Arctic Monkeys", "artistIds": ["7Ln80lUS6He07XvHI8qqHH"], "artistNames": ["Arctic Monkeys"], "playCount": 316003496, "discNumber": 1, "trackNumber": 1, "durationMs": 172866, "contentRating": "NONE", "isExplicit": false, "isPlayable": true, "observedAt": "2026-07-19T02:00:00.000Z" } ``` Play counts change continuously, so the example count is illustrative. ### How much does it cost to scrape Spotify play counts? The Actor uses pay-per-event pricing: - A **$0.005 one-time start event** covers fixed session bootstrap. - Each unique track row costs **$0.00007793 on FREE**, **$0.000067765 on BRONZE**, **$0.000052857 on SILVER**, **$0.000040659 on GOLD**, **$0.000027106 on PLATINUM**, or **$0.000018974 on DIAMOND**. - Subscription-tier discounts are applied automatically. At BRONZE pricing, a 12-track album costs about **$0.00581** ($0.005 start plus 12 track events). A 100-track snapshot costs about **$0.01178**. For cost control, use a single track or small album first. The default input caps output at 20 tracks in the prefilled example. Apify's free plan can be used for small evaluations subject to the current platform allowance. ### Monitoring Spotify stream growth A play count is cumulative. To calculate growth, schedule the Actor and compare two observations with the same `trackId`: ```text streamDelta = current.playCount - previous.playCount ``` You can also calculate average velocity: ```text streamsPerHour = streamDelta / hoursBetweenObservations ``` Store each run's dataset in your warehouse or send it through a webhook. Use `observedAt` rather than the run start shown in an external scheduler, because `observedAt` is attached directly to every result. ### Artist catalog behavior Artist URLs intentionally use bounded expansion. Spotify artists may have many albums, deluxe editions, compilations, and singles. `maxAlbumsPerArtist` keeps runtime and output predictable. The Actor processes albums first, then singles when enabled, and deduplicates release and track IDs. If you need one historical album, pass that album URL directly instead of increasing the artist limit. ### Tips for reliable results - ✅ Use canonical `open.spotify.com` links copied from Spotify. - ✅ Start with one URL before submitting a batch. - ✅ Use track URLs for exact single-record monitoring. - ✅ Use album URLs when release completeness matters. - ✅ Keep artist release limits focused on the campaign period. - ✅ Join snapshots by `trackId`, not by title alone. - ✅ Treat counts from different `observedAt` timestamps as separate observations. - ❌ Do not send playlist or podcast URLs; they are outside this Actor's scope. ### Apify API with cURL Start a run: ```bash curl -X POST \ "https://api.apify.com/v2/acts/automation-lab~spotify-track-play-count-scraper/runs?token=$APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "spotifyUrls": ["https://open.spotify.com/track/7MXVkk9YMctZqd1Srtv4MB"], "maxTracks": 1 }' ``` Fetch dataset items after the run succeeds: ```bash curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json" ``` ### Apify API with JavaScript Install the client: ```bash npm install apify-client ``` Run the Actor: ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor('automation-lab/spotify-track-play-count-scraper').call({ spotifyUrls: ['https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm'], maxTracks: 20, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` ### Apify API with Python Install the client: ```bash pip install apify-client ``` Run and read results: ```python import os from apify_client import ApifyClient client = ApifyClient(os.environ['APIFY_TOKEN']) run = client.actor('automation-lab/spotify-track-play-count-scraper').call(run_input={ 'spotifyUrls': ['https://open.spotify.com/track/7MXVkk9YMctZqd1Srtv4MB'], 'maxTracks': 1, }) items = list(client.dataset(run['defaultDatasetId']).iterate_items()) print(items) ``` ### Integrations and automation workflows #### Google Sheets and Airtable Schedule daily runs, then send rows to a sheet keyed by `trackId` and `observedAt`. Use a pivot table or formula to calculate changes between snapshots. #### Make and Zapier Trigger the Actor from a release-tracking scenario. Send tracks whose delta exceeds a threshold to Slack, email, or a campaign dashboard. #### Webhooks and data warehouses Attach an Apify run-succeeded webhook. Load the dataset into BigQuery, Snowflake, PostgreSQL, or S3 for long-term history. #### Tableau, Power BI, and Looker Studio Read clean CSV/JSON exports and chart play-count velocity by release, artist, or campaign window. ### Use with Apify MCP and AI assistants Connect the Actor to Claude Code: ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/spotify-track-play-count-scraper" ``` For Claude Desktop, Cursor, or VS Code, add this MCP server configuration: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=automation-lab/spotify-track-play-count-scraper" } } } ``` Example prompts: - “Get the exact Spotify play counts for every track on this album URL.” - “Snapshot the newest three releases for this artist and sort tracks by play count.” - “Look up this track's current count and format the result for my monitoring table.” - “Compare this dataset with yesterday's snapshot by Spotify track ID.” ### Scheduling daily or weekly snapshots Create an Apify schedule with stable input URLs and limits. Daily schedules work well for active launches. Weekly schedules are often sufficient for back-catalog monitoring. Keep the input unchanged when you want clean time-series comparisons. If you alter artist release limits, record that change in your downstream pipeline because the observed catalog set may change. ### Data quality and limitations Counts come from Spotify's current public web-client data surface. They are observations, not royalty statements and not predictions. Spotify can update counts at its own cadence. Regional playability may vary. Artist expansion is bounded and does not claim to retrieve an unlimited full discography. Persisted web-client operations are undocumented and can change. The Actor detects missing response branches and invalid counts so failures are visible. ### Is scraping Spotify play counts legal? This Actor accesses public catalog information without logging into a user account. Web scraping laws and contractual requirements vary by country and use case. You are responsible for using the data lawfully, respecting applicable terms, protecting personal data, and avoiding harmful or excessive automation. Do not use the Actor to download audio, bypass access controls, impersonate users, or interfere with Spotify's service. When in doubt, consult qualified legal counsel. ### Troubleshooting #### Why did my URL fail validation? Use a full `https://open.spotify.com/artist/...`, `/album/...`, or `/track/...` URL. Playlist, shortened, URI-only, and non-Spotify links are not accepted. #### Why did an artist return fewer releases than expected? Check `maxAlbumsPerArtist`, `includeSingles`, and `maxTracks`. For a specific older release, submit its album URL directly. #### Why did the run report Pathfinder compatibility failure? Spotify may have changed an undocumented public query or response schema. Retry once with a canonical URL. If the error continues, share the run with the Actor developer so the operation can be updated; the Actor deliberately does not estimate missing counts. #### Why are two play-count snapshots different? Spotify play counts are cumulative and can update between runs. Use `observedAt` to order observations and compute deltas. ### FAQ #### Does the Actor need a Spotify API key? No. It bootstraps an anonymous public Spotify session. #### Does it require a Spotify account or cookies? No user login or private cookie is required. #### Are play counts exact or estimated? The `playCount` value is the exact numeric value returned by Spotify's public web client at observation time. #### Can it scrape playlists? No. This focused Actor supports artist, album, and track URLs. #### Can it monitor several artists? Yes. Add up to 20 supported source URLs and set a sensible global `maxTracks` cap. #### Does it save historical data automatically? Each run creates a timestamped snapshot dataset. Use Apify schedules and a downstream sheet, database, or warehouse to retain and compare snapshots. #### Can I export to Excel or CSV? Yes. Apify datasets support Excel, CSV, JSON, XML, and HTML exports. ### Related Spotify scrapers - [Spotify Scraper](https://apify.com/automation-lab/spotify-scraper) — broader artist, track, album, playlist, and search metadata workflows. - [Spotify Songs Scraper](https://apify.com/automation-lab/spotify-songs-scraper) — song catalog metadata and discovery workflows. - [Spotify Track Play Count Scraper](https://apify.com/automation-lab/spotify-track-play-count-scraper) — focused exact stream-count snapshots and monitoring. ### Start tracking Spotify play counts Add a Spotify track for a one-row lookup, an album for complete release counts, or an artist for a bounded recent-catalog snapshot. Start small, verify the rows, then schedule the same input to measure stream growth over time. # Actor input Schema ## `spotifyUrls` (type: `array`): Add 1–20 public Spotify URLs, such as https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm. Playlist and non-Spotify URLs are rejected. ## `maxTracks` (type: `integer`): Stop after this many unique track rows across all source URLs. ## `maxAlbumsPerArtist` (type: `integer`): For each artist URL, inspect this many newest album/single releases. ## `includeSingles` (type: `boolean`): Include singles as well as albums when expanding artist URLs. ## Actor input object example ```json { "spotifyUrls": [ "https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm" ], "maxTracks": 20, "maxAlbumsPerArtist": 3, "includeSingles": true } ``` # Actor output Schema ## `trackPlayCounts` (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 = { "spotifyUrls": [ "https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm" ], "maxTracks": 20, "maxAlbumsPerArtist": 3, "includeSingles": true }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/spotify-track-play-count-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 = { "spotifyUrls": ["https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm"], "maxTracks": 20, "maxAlbumsPerArtist": 3, "includeSingles": True, } # Run the Actor and wait for it to finish run = client.actor("automation-lab/spotify-track-play-count-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 '{ "spotifyUrls": [ "https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm" ], "maxTracks": 20, "maxAlbumsPerArtist": 3, "includeSingles": true }' | apify call automation-lab/spotify-track-play-count-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=automation-lab/spotify-track-play-count-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Spotify Track Play Count Scraper", "description": "🎵 Get exact Spotify track stream counts from public artist, album, and track URLs. Export timestamped rows for release velocity, catalog analysis, and scheduled monitoring—no Spotify API key or login.", "version": "0.1", "x-build-id": "9x26irD2cwA1pbgoX" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/automation-lab~spotify-track-play-count-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-automation-lab-spotify-track-play-count-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~spotify-track-play-count-scraper/runs": { "post": { "operationId": "runs-sync-automation-lab-spotify-track-play-count-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~spotify-track-play-count-scraper/run-sync": { "post": { "operationId": "run-sync-automation-lab-spotify-track-play-count-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": [ "spotifyUrls" ], "properties": { "spotifyUrls": { "title": "Spotify artist, album, or track URLs", "minItems": 1, "maxItems": 20, "type": "array", "description": "Add 1–20 public Spotify URLs, such as https://open.spotify.com/album/1XkGORuUX2QGOEIL4EbJKm. Playlist and non-Spotify URLs are rejected.", "items": { "type": "string" } }, "maxTracks": { "title": "Maximum track observations", "minimum": 1, "maximum": 1000, "type": "integer", "description": "Stop after this many unique track rows across all source URLs.", "default": 100 }, "maxAlbumsPerArtist": { "title": "Releases per artist", "minimum": 1, "maximum": 20, "type": "integer", "description": "For each artist URL, inspect this many newest album/single releases.", "default": 3 }, "includeSingles": { "title": "Include artist singles", "type": "boolean", "description": "Include singles as well as albums when expanding artist URLs.", "default": true } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```