# Victoria & Albert Museum Collection Scraper (`parseforge/va-museum-collection-scraper`) Actor

Search the Victoria and Albert Museum collection and pull one clean record per object with title, maker, production date, place, materials, dimensions, gallery location, and a ready IIIF image. Filter by maker or object type. Great for design research and cultural datasets.

- **URL**: https://apify.com/parseforge/va-museum-collection-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏛 Victoria & Albert Museum Collection Scraper

> 🚀 **Pull V&A museum objects in seconds.** Search 1.2M+ catalogued objects and get clean records with titles, makers, dates, materials, dimensions, gallery location, and high-quality IIIF images.

> 🕒 **Last updated:** 2026-06-05 · **📊 15 fields** per record · IIIF image links · Full V&A collection coverage

The Victoria & Albert Museum (V&A) in London holds one of the world's largest collections of art, design, and performance, spanning over 5,000 years of human creativity. This scraper turns the V&A's public collection into a structured feed you can analyse, enrich, or build on.

Point it at any search term (chair, kimono, poster, teapot, Wedgwood) and it returns one clean record per object, enriched from the V&A object detail endpoint so materials, techniques, dimensions, and gallery location come through cleanly instead of as raw codes.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Researchers and academics | Art and design history research |
| Cultural heritage and GLAM teams | Collection analysis and cataloguing |
| Educators and students | Teaching material and study sets |
| Designers and creatives | Visual reference and inspiration libraries |
| Data scientists and developers | Building cultural datasets and apps |

### 📋 What the Victoria & Albert Museum Collection Scraper does

This Actor queries the official Victoria & Albert Museum API v2, then enriches every result with the per-object detail record. For each museum object it returns:

- The primary IIIF image, served at 400x400 from the V&A image server
- Object title, type, accession number, and stable system number
- Maker or artist with their role (designer, manufacturer, maker)
- Production date and place of origin
- Materials, techniques, and physical dimensions
- Gallery or storage location and a short description
- A direct link to the object page on the V&A site

You control the search with a query plus optional maker and object type filters.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | No | Free-text search across the collection. Defaults to `chair`. |
| `maxItems` | integer | No | Cap on the number of objects returned. Free plan is limited to 10. |
| `maker` | string | No | Narrow results to a maker, artist, designer, or manufacturer. |
| `objectType` | string | No | Narrow results to an object type (Armchair, Vase, Photograph). |
| `pageSize` | integer | No | Records requested per API page (1 to 100). Defaults to 20. |

**Example 1 — broad search**
```json
{
  "query": "kimono",
  "maxItems": 25
}
````

**Example 2 — maker and type filter**

```json
{
  "query": "cabinet",
  "maker": "Chippendale",
  "objectType": "Armchair",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** The V\&A search ranks loosely, so a broad query can surface related objects beyond the exact term. Use the `maker` and `objectType` filters to tighten results. Some objects have no recorded technique or maker, in which case those fields come back empty rather than fabricated.

### 📊 Output

Each object becomes one record. Field schema:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | Primary object image (IIIF, 400x400 JPEG) |
| 📌 `title` | Object title |
| 🏷 `objectType` | Type of object (Chair, Vase, Photograph) |
| 🎨 `artist` | Maker or artist with role |
| 📅 `date` | Production date |
| 📍 `place` | Place of origin |
| 🧵 `materials` | Materials used |
| 🛠 `techniques` | Techniques used |
| 📐 `dimensions` | Physical dimensions with units |
| 🏛 `location` | Gallery or storage location |
| 📝 `briefDescription` | Short object description |
| 🆔 `systemNumber` | Stable V\&A system number |
| 🔖 `accessionNumber` | Museum accession number |
| 🔗 `objectUrl` | Link to the object on the V\&A site |
| 🕒 `scrapedAt` | Timestamp of collection |
| ❌ `error` | Null on success, message on failure |

**Real sample records:**

```json
{
  "imageUrl": "https://framemark.vam.ac.uk/collections/2006AU1797/full/!400,400/0/default.jpg",
  "title": "Ply Chair",
  "objectType": "Chair",
  "artist": "Morrison, Jasper (designer)",
  "date": "1990",
  "place": "Great Britain",
  "materials": "plywood, veneer",
  "techniques": "sawing",
  "dimensions": "Height: 85 cm, Width: 40 cm, Depth: 50 cm",
  "location": "006",
  "briefDescription": "Ply-chair with back designed by Jasper Morrison, 1990",
  "systemNumber": "O72610",
  "accessionNumber": "W.2-1995",
  "objectUrl": "https://collections.vam.ac.uk/item/O72610",
  "scrapedAt": "2026-06-05T17:41:12.716Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://framemark.vam.ac.uk/collections/2013GT3689/full/!400,400/0/default.jpg",
  "title": "Joan's chair",
  "objectType": "Chair",
  "artist": "Heal, Ambrose (Sir) (designer); Christine Angus (designer)",
  "date": "1901",
  "place": "England",
  "materials": "oak",
  "techniques": "inlay",
  "dimensions": "Height: 157.5 cm, Depth: 58 cm, Width: 70 cm",
  "location": "SR042",
  "briefDescription": "An Arts & Crafts Chair by Ambrose Heal, England, 1901",
  "systemNumber": "O1264771",
  "accessionNumber": "B.1-2013",
  "objectUrl": "https://collections.vam.ac.uk/item/O1264771",
  "scrapedAt": "2026-06-05T17:41:12.862Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://framemark.vam.ac.uk/collections/2015HX9943/full/!400,400/0/default.jpg",
  "title": "21400 mm chair",
  "objectType": "Chair",
  "artist": "nendo (designer)",
  "date": "2010",
  "place": "Tokyo (city)",
  "materials": "steel",
  "techniques": "bent, welding, coating, Powder coated",
  "dimensions": "Height: 66 cm, Width: 78 cm, Depth: 76 cm, Weight: 6.35 kg",
  "location": "CA003",
  "briefDescription": "Chair, '21400 mm chair', Thin Black Lines collection designed by nendo (Oki Sato) and manufactured by Ochiai-Seisakusho Co. Ltd, steel, 2010",
  "systemNumber": "O1243361",
  "accessionNumber": "W.28-2011",
  "objectUrl": "https://collections.vam.ac.uk/item/O1243361",
  "scrapedAt": "2026-06-05T17:41:12.976Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Enriched, not raw.** Every object is pulled from the detail endpoint so materials, techniques, and dimensions arrive clean.
- **Image first.** Each record leads with a ready IIIF image link you can drop straight into a gallery or sheet.
- **Honest fields.** Empty values stay empty. No fabricated makers or dates.
- **Stable identifiers.** System and accession numbers let you join back to the V\&A at any time.
- **Filter where it counts.** Maker and object type filters narrow huge result sets to what you need.

### 📈 How it compares to alternatives

| Approach | Image links | Enriched fields | Filters | Structured output |
|---|---|---|---|---|
| This Actor | Yes (IIIF) | Yes | Maker, type | Yes |
| Manual website browsing | View only | Manual copy | UI only | No |
| Raw API calls | Image IDs only | Extra coding | Yes | Build yourself |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Victoria & Albert Museum Collection Scraper.
3. Enter a search query and any optional maker or object type filter.
4. Click **Start** and watch records fill the dataset.
5. Download or connect the results to your tools and workflows.

### 💼 Business use cases

**Cultural heritage and research**
| Need | How this helps |
|---|---|
| Build a study dataset | Pull thousands of objects with consistent fields |
| Track a maker's output | Filter by maker across the whole collection |

**Design and creative**
| Need | How this helps |
|---|---|
| Mood and reference boards | Image-first records ready to embed |
| Material and technique study | Clean materials and techniques per object |

**Education**
| Need | How this helps |
|---|---|
| Teaching sets | Curated object lists by theme |
| Student projects | Structured data without manual copying |

**Data and product**
| Need | How this helps |
|---|---|
| Power a cultural app | Stable IDs and image links to build on |
| Enrich a catalogue | Join V\&A records to your own data |

### 🔌 Automating Victoria & Albert Museum Collection Scraper

Connect this Actor to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into apps
- **Slack** to post new finds to a channel
- **Airbyte** to sync results into a warehouse
- **GitHub** to version controlled data pipelines
- **Google Drive** to archive image sets and sheets

### 🌟 Beyond business use cases

- **Research** into design history, provenance, and material culture
- **Personal** collections, hobby cataloguing, and learning projects
- **Non-profit** and community heritage initiatives
- **Experimentation** with generative art, search, and recommendation models

### 🤖 Ask an AI assistant

Drop your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarise makers, cluster by material, or build a timeline of an object type.

### ❓ Frequently Asked Questions

**Is the data official?**
Yes. It comes from the official Victoria & Albert Museum API v2.

**Do I need an API key?**
No. The V\&A API is open, so you only need an Apify account to run the Actor.

**What identifies each object?**
The V\&A system number and the museum accession number, both included in every record.

**Where do the images come from?**
The V\&A IIIF image server. Each record links to a 400x400 JPEG of the primary image.

**Can I get larger images?**
The link follows the V\&A IIIF pattern, so the size segment can be adjusted at the source for higher resolutions.

**How do the filters work?**
`maker` narrows to a person or organisation, and `objectType` narrows to a category like Armchair or Vase.

**Why is a field sometimes empty?**
Some objects have no recorded maker, technique, or date. Empty values are kept honest rather than guessed.

**How many objects can I collect?**
Free plans are capped at 10 per run. Paid plans can collect up to 1,000,000.

**Does it cover every V\&A object?**
It searches the full public collection. Results depend on your query and filters.

**Can I run it on a schedule?**
Yes. Use Apify Schedules to run it automatically and capture new additions.

### 🔌 Integrate with any app

Results are available through the Apify API and dataset endpoints, so you can pipe records into spreadsheets, databases, dashboards, or custom apps.

### 🔗 Recommended Actors

- [The Met Collection Scraper](https://apify.com/parseforge)
- [Smithsonian Open Access Scraper](https://apify.com/parseforge)
- [Art Institute of Chicago Scraper](https://apify.com/parseforge)
- [Europeana Cultural Heritage Scraper](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the Victoria & Albert Museum. Only publicly available data is collected.

# Actor input Schema

## `query` (type: `string`):

Free-text search across the V\&A collection (object titles, makers, descriptions). Example: chair, teapot, kimono, poster.

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `maker` (type: `string`):

Optional. Narrow results to a specific maker, artist, designer, or manufacturer. Example: Chippendale, Morris, Wedgwood.

## `objectType` (type: `string`):

Optional. Narrow results to a specific object type. Example: Armchair, Vase, Photograph, Dress.

## `pageSize` (type: `integer`):

Number of records requested per API page (1-100). Controls batching only, not the total. Use Max Items to cap totals.

## Actor input object example

```json
{
  "query": "chair",
  "maxItems": 10,
  "pageSize": 20
}
```

# Actor output Schema

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

// Prepare Actor input
const input = {
    "query": "chair",
    "maxItems": 10,
    "pageSize": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/va-museum-collection-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 = {
    "query": "chair",
    "maxItems": 10,
    "pageSize": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/va-museum-collection-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 '{
  "query": "chair",
  "maxItems": 10,
  "pageSize": 20
}' |
apify call parseforge/va-museum-collection-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/va-museum-collection-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Victoria & Albert Museum Collection Scraper",
        "description": "Search the Victoria and Albert Museum collection and pull one clean record per object with title, maker, production date, place, materials, dimensions, gallery location, and a ready IIIF image. Filter by maker or object type. Great for design research and cultural datasets.",
        "version": "0.1",
        "x-build-id": "eUGY6cmI8Dm15PRfu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~va-museum-collection-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-va-museum-collection-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/parseforge~va-museum-collection-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-va-museum-collection-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/parseforge~va-museum-collection-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-va-museum-collection-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": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text search across the V&A collection (object titles, makers, descriptions). Example: chair, teapot, kimono, poster."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "maker": {
                        "title": "Maker / Artist",
                        "type": "string",
                        "description": "Optional. Narrow results to a specific maker, artist, designer, or manufacturer. Example: Chippendale, Morris, Wedgwood."
                    },
                    "objectType": {
                        "title": "Object Type",
                        "type": "string",
                        "description": "Optional. Narrow results to a specific object type. Example: Armchair, Vase, Photograph, Dress."
                    },
                    "pageSize": {
                        "title": "Results Per API Page",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of records requested per API page (1-100). Controls batching only, not the total. Use Max Items to cap totals."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
