# Spotify Preview URL Scraper (`beatanalytics/spotify-preview-url-scraper`) Actor

Get 30-second MP3 preview URLs for any Spotify track — even where the official Spotify Web API returns preview\_url: null. Bulk track URLs or IDs in, direct audio preview links out. No Spotify developer account or API credentials needed. Export as JSON, CSV, or Excel.

- **URL**: https://apify.com/beatanalytics/spotify-preview-url-scraper.md
- **Developed by:** [Beat Analytics](https://apify.com/beatanalytics) (community)
- **Categories:** Developer tools, Social media, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 tracks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Spotify Preview URL Scraper - Get 30-Second MP3 Preview URLs Even When `preview_url` Is Null

Spotify removed preview URLs from its Web API, and for most developers the `preview_url` field now comes back **`null`** on every track. **Spotify Preview URL Scraper** gives you those links back: paste in any Spotify track URL (or a bulk list of them) and get the direct 30-second MP3 preview URL for each one. No Spotify developer account, no API keys, no OAuth - just track URLs in, playable audio preview links out.

It is maintained, so there is nothing for you to host, patch, or babysit when Spotify changes its markup.

### Why is `preview_url` null in the Spotify API?

On **November 27, 2024**, Spotify changed the Web API so that the `preview_url` field is no longer populated for apps created after that date. If you register a new Spotify application today, every track you look up returns `"preview_url": null` - for tracks, for albums, for playlists, everywhere. Spotify has confirmed this is intentional and permanent, not a bug, and there is no setting or scope that turns it back on.

That left a lot of Heardle clones, music-quiz games, discovery apps, and audio-ML pipelines suddenly broken. The 30-second preview clips still exist and still play inside Spotify's own web player and embeds; they are just no longer handed to you through the official API.

Spotify Preview URL Scraper reads those preview URLs directly, so you get the same `https://p.scdn.co/mp3-preview/...` links you used to get from the API, without an API key and without the field ever being `null` again.

### Why use this Spotify preview URL scraper?

- 🎧 **Gets the preview URL even when the Spotify API returns `preview_url: null`** - the exact links missing from the official Web API since the 2024 deprecation
- 🔑 **No Spotify developer account or API credentials needed** - no client ID, no client secret, no OAuth, no app registration
- 📦 **Bulk input** - drop in one track or thousands of track URLs / IDs in a single run
- 💸 **Pay per result, no subscription** - no monthly fee and no per-run start fee; you pay only for the preview URLs you get back
- 🛠️ **Nothing to host or maintain** - no self-hosted script that silently breaks the next time Spotify changes its page markup
- 🎵 **Direct, playable MP3 links** - each result is a ready-to-use `p.scdn.co` 30-second preview clip you can stream, download, or feed into your app
- 📤 **Export anywhere** - download results as JSON, CSV, Excel, XML, or HTML, or pull them straight from the Apify API

### What data can you extract with the Spotify Preview URL Scraper?

For every track you provide, the scraper returns:

| Field | Type | Description |
|---|---|---|
| `trackUrl` | string | Canonical Spotify track URL (`https://open.spotify.com/track/...`) |
| `trackId` | string | Spotify track ID (the 22-character base62 ID) |
| `previewUrl` | string | Direct 30-second MP3 audio preview URL (`https://p.scdn.co/mp3-preview/...`) |

The `previewUrl` is a standard MP3 file you can play in an `<audio>` tag, download, or process however you like.

### How to scrape Spotify preview URLs

You don't need any coding experience to get started:

1. **Create a free Apify account** - sign up at [apify.com](https://apify.com); no credit card required, and new accounts include free usage credits.
2. **Open the Spotify Preview URL Scraper** - from the Apify Store, click **Try for free**.
3. **Add your tracks** - paste one or more Spotify track URLs into **Track URLs** (or paste bare 22-character track IDs into **Track IDs**). You can add thousands at once.
4. **Click Start** - the scraper fetches the preview URL for each track in parallel.
5. **Download your results** - export the dataset as JSON, CSV, or Excel, or grab it from the Apify API.

### Input parameters

| Parameter | Field | Type | Description |
|---|---|---|---|
| Track URLs | `trackUrls` | array | Spotify track URLs to get preview URLs for. Supports full URLs (`open.spotify.com/track/...`) and track URIs (`spotify:track:...`). |
| Track IDs | `trackIds` | array | Spotify track IDs (the 22-character ID from a track URL). Use instead of or in addition to Track URLs. |

Provide at least one track URL or track ID. Duplicate tracks (whether supplied as a URL or an ID) are automatically deduplicated, so you're never charged twice for the same track.

Example input:

```json
{
    "trackUrls": [
        { "url": "https://open.spotify.com/track/2x8evxqUlF0eRabbW2JBJd" },
        { "url": "https://open.spotify.com/track/4uLU6hMCjMI75M1A2tKUQC" }
    ],
    "trackIds": ["3z8h0TU7ReDPLIbEnYhWZb"]
}
````

### Output example

Each track produces one dataset record like this:

```json
{
    "trackUrl": "https://open.spotify.com/track/2x8evxqUlF0eRabbW2JBJd",
    "trackId": "2x8evxqUlF0eRabbW2JBJd",
    "previewUrl": "https://p.scdn.co/mp3-preview/5d554321da6089f449862bf515d63fe3f80829f9"
}
```

Results are available the moment the run finishes, and Apify exports the whole dataset in every common format automatically - **JSON, CSV, Excel, XML, and HTML** - or streams it through the Apify API into your own systems.

### How much does it cost to scrape Spotify preview URLs?

**$4.00 per 1,000 preview URLs** - each track you successfully get a preview URL for counts as one result. Getting preview URLs for 250 tracks costs $1.00. There is no per-run start fee: you pay purely for results, and tracks with no available preview are skipped free of charge.

Every new Apify account includes **$5 in free credits**, enough to pull over 1,200 preview URLs at no cost. Enterprise plans with custom pricing and dedicated support are available; contact <sales@beatanalytics.org> for details.

### Use cases for Spotify preview URLs

- **Song-guessing and Heardle-style games** - power the audio round of a music quiz with the 30-second clips your app lost when Spotify deprecated the API field
- **Music discovery apps** - let users preview tracks before they open them in Spotify, with real playable audio instead of dead `null` fields
- **Snippet players and preview widgets** - embed short, licensed audio previews on artist pages, blogs, or playlist widgets
- **Audio-ML and research datasets** - collect preview clips in bulk as training or evaluation data for genre classification, audio fingerprinting, mood detection, and similar models
- **Playlist preview tools** - generate a scrollable, playable preview reel for an entire playlist or catalog
- **Music catalog and metadata enrichment** - backfill preview links into a catalog whose Spotify API integration now returns `null`

### Integrations and API access

Spotify Preview URL Scraper runs on the Apify platform, so you can call it programmatically and wire its output into thousands of external tools.

#### Python

Use the [Apify Python SDK](https://docs.apify.com/sdk/python/) to run the scraper and retrieve preview URLs programmatically:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "trackUrls": [
        {"url": "https://open.spotify.com/track/2x8evxqUlF0eRabbW2JBJd"},
        {"url": "https://open.spotify.com/track/4uLU6hMCjMI75M1A2tKUQC"},
    ],
}

run = client.actor("beatanalytics/spotify-preview-url-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['trackId']} -> {item['previewUrl']}")
```

#### JavaScript / Node.js

Use the [Apify JavaScript SDK](https://docs.apify.com/sdk/js/) to integrate preview URL scraping into your Node.js app:

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("beatanalytics/spotify-preview-url-scraper").call({
    trackIds: ["2x8evxqUlF0eRabbW2JBJd", "4uLU6hMCjMI75M1A2tKUQC"],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.log(`${item.trackId} -> ${item.previewUrl}`);
});
```

#### No-code integrations

Connect Spotify Preview URL Scraper to thousands of apps without writing code:

- **Make (formerly Integromat)** - trigger a workflow whenever new preview URLs are scraped, or schedule recurring runs
- **Zapier** - push preview URLs into Google Sheets, Airtable, databases, and 5,000+ other apps
- **Webhooks** - get an HTTP notification when a run finishes, then process the results in your own backend
- **Google Sheets / Amazon S3 / Dropbox** - export preview URLs directly to spreadsheets or cloud storage

#### API endpoints

Every run exposes RESTful API endpoints for accessing results, checking run status, and managing datasets. See the [Apify API documentation](https://docs.apify.com/api/v2) for the full reference.

### Frequently asked questions

#### Why is `preview_url` null in the Spotify API?

Because Spotify deprecated it. As of **November 27, 2024**, the Web API no longer returns preview URLs for newly created apps - `preview_url` is permanently `null` for those apps, and Spotify has stated this is intentional. The clips still exist inside Spotify's player; they are just no longer exposed through the official API. This scraper reads them directly, so you get real preview URLs instead of `null`.

#### Do I need a Spotify API key or developer account?

No. You don't need a Spotify client ID, client secret, developer account, or OAuth flow of any kind. You provide plain Spotify track URLs (or IDs), and the scraper returns the preview URLs. Everything runs on Apify.

#### Are Spotify preview URLs deprecated for everyone?

The **API field** is deprecated for apps created after November 27, 2024, and Spotify has said it won't be brought back. Older apps may still see it for now, but relying on that is risky. This scraper doesn't depend on the API field at all, so it keeps returning preview URLs regardless of when your Spotify app was created, or whether you have one.

#### What does a preview URL look like?

It's a direct MP3 link on Spotify's CDN, in the form `https://p.scdn.co/mp3-preview/<hash>`. You can play it in an HTML `<audio>` element, download it, or feed it into audio processing. It's a standard 30-second MP3 clip.

#### How long are the preview clips?

Spotify preview clips are **30 seconds** long. They're the same short audio snippets Spotify uses in its own web player previews.

#### What if a track has no preview?

Some tracks genuinely have no preview clip available, usually because of regional or label/licensing restrictions. When a track has no available preview, it is simply **skipped** and doesn't appear in your results, so you're not charged for it. Every result you do get back has a real, playable preview URL.

#### Can I get preview URLs for a whole playlist or album at once?

This actor takes **track** URLs and IDs. To cover a full playlist or album, expand it to its track list first (for example with a playlist/album track scraper), then feed those track URLs in here. Deduplication means overlapping tracks across playlists are only fetched once.

#### How many tracks can I scrape at once?

There's no fixed limit; you can submit thousands of track URLs or IDs in a single run. Requests are made concurrently, so large batches complete quickly, and you pay per result.

#### Can I get the actual play counts or stream numbers too?

Yes, but that's a different data point. For real Spotify stream counts and monthly-listener numbers, data the official API also doesn't expose, use the [Spotify Play Count Scraper](https://apify.com/beatanalytics/spotify-play-count-scraper), a sibling actor from the same team.

#### Is scraping Spotify preview URLs legal?

The scraper accesses publicly available preview clips that Spotify already serves to anyone using its web player and embeds. As with any scraping, you're responsible for how you use the data - review Spotify's terms and your local regulations, and use preview clips in line with applicable licensing. This tool doesn't access any private, paid, or authenticated content.

#### What input formats are accepted?

Full track URLs (`https://open.spotify.com/track/...`), Spotify track URIs (`spotify:track:...`), and bare 22-character track IDs. Mix and match them freely across the **Track URLs** and **Track IDs** inputs.

### Related actors

**[Spotify Play Count Scraper](https://apify.com/beatanalytics/spotify-play-count-scraper)**

Real stream counts, play counts, and monthly-listener numbers that the Spotify Web API doesn't expose, for any artist, album, or track. Pull a catalog's preview URLs here and its play counts there to pair playable audio with popularity data.

Building something that needs more Spotify data? [Get in touch](mailto:sales@beatanalytics.org) - we're expanding the catalog.

# Actor input Schema

## `trackUrls` (type: `array`):

Spotify track URLs to get 30-second MP3 preview URLs for. Supports full URLs (open.spotify.com/track/...) and track URIs (spotify:track:...).

## `trackIds` (type: `array`):

Spotify track IDs (the 22-character ID from a track URL, e.g. 2x8evxqUlF0eRabbW2JBJd). Can be used instead of or in addition to Track URLs.

## Actor input object example

```json
{
  "trackUrls": [
    {
      "url": "https://open.spotify.com/track/2x8evxqUlF0eRabbW2JBJd"
    }
  ]
}
```

# Actor output Schema

## `previewUrls` (type: `string`):

All scraped tracks with their 30-second MP3 preview URLs.

## `csv` (type: `string`):

Preview URLs exported as a CSV file.

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "trackUrls": [
        {
            "url": "https://open.spotify.com/track/2x8evxqUlF0eRabbW2JBJd"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("beatanalytics/spotify-preview-url-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "trackUrls": [{ "url": "https://open.spotify.com/track/2x8evxqUlF0eRabbW2JBJd" }] }

# Run the Actor and wait for it to finish
run = client.actor("beatanalytics/spotify-preview-url-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 '{
  "trackUrls": [
    {
      "url": "https://open.spotify.com/track/2x8evxqUlF0eRabbW2JBJd"
    }
  ]
}' |
apify call beatanalytics/spotify-preview-url-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=beatanalytics/spotify-preview-url-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Spotify Preview URL Scraper",
        "description": "Get 30-second MP3 preview URLs for any Spotify track — even where the official Spotify Web API returns preview_url: null. Bulk track URLs or IDs in, direct audio preview links out. No Spotify developer account or API credentials needed. Export as JSON, CSV, or Excel.",
        "version": "1.0",
        "x-build-id": "BrFHEbRszOzBvXbKn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/beatanalytics~spotify-preview-url-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-beatanalytics-spotify-preview-url-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/beatanalytics~spotify-preview-url-scraper/runs": {
            "post": {
                "operationId": "runs-sync-beatanalytics-spotify-preview-url-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/beatanalytics~spotify-preview-url-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-beatanalytics-spotify-preview-url-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": {
                    "trackUrls": {
                        "title": "Track URLs",
                        "type": "array",
                        "description": "Spotify track URLs to get 30-second MP3 preview URLs for. Supports full URLs (open.spotify.com/track/...) and track URIs (spotify:track:...).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "trackIds": {
                        "title": "Track IDs",
                        "type": "array",
                        "description": "Spotify track IDs (the 22-character ID from a track URL, e.g. 2x8evxqUlF0eRabbW2JBJd). Can be used instead of or in addition to Track URLs.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```