# Cleveland Museum of Art Scraper (`parseforge/cleveland-museum-of-art-scraper`) Actor

Search the Cleveland Museum of Art open access collection for public domain artworks. Pull CC0 image URLs, title, artist, creation date, medium, dimensions, department, and culture. Great for art research, machine learning datasets, and building galleries or catalogs.

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

## Pricing

from $2.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)

## 🖼 Cleveland Museum of Art Scraper

> 🚀 **Pull CC0 open access artworks in seconds.** Search 41,000+ image-backed works across 18 curatorial departments, each with a free-to-use image URL and a clean object record.

> 🕒 **Last updated:** 2026-06-05 · **📊 19 fields** per record · 41,000+ image-backed artworks · full public domain (CC0) collection

The Cleveland Museum of Art Scraper turns the museum's Open Access API into a structured, ready-to-use dataset. Every record carries a CC0 image URL plus the catalog facts behind the object: title, artist, creation date, medium, dimensions, department, culture, and a link back to the museum page.

**Coverage.** The Cleveland Museum of Art has released tens of thousands of works under CC0 (Creative Commons Zero, public domain). This Actor reads the same Open Access API the museum publishes, so you get paintings, prints, drawings, textiles, photographs, sculpture, and more, filtered by keyword, department, or object type.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Researchers, educators, designers, data scientists, GLAM and digital humanities teams | Building art datasets, training image models on public domain art, populating galleries and apps, classroom resources, provenance and collection research |

### 📋 What the Cleveland Museum of Art Scraper does

- Searches the museum's Open Access collection by free text keyword (artist, title, subject).
- Filters by curatorial department or by object type.
- Returns only artworks that carry a CC0 image when you ask for image-backed records.
- Flattens each artwork into a single record with the headline image URL first.
- Captures artist, creation date, medium, measurements, department, culture, credit line, and the canonical museum URL.
- Keeps the full creators list and a higher resolution print image URL for downstream use.

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

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | No | Free text search across titles, artists, and descriptions. Leave empty to browse the whole collection. |
| `department` | string (select) | No | Limit to one curatorial department, for example Photography or Japanese Art. |
| `type` | string | No | Limit to one object type, for example Painting, Drawing, Print, Sculpture. |
| `hasImage` | boolean | No | When on, only artworks with a CC0 image are returned. Defaults to on. |
| `maxItems` | integer | No | How many records to collect. Free plan is capped at 10. |

Example 1, browse image-backed works (default):

```json
{
  "hasImage": true,
  "maxItems": 25
}
````

Example 2, keyword search inside a department:

```json
{
  "query": "monet",
  "department": "Modern European Painting and Sculpture",
  "type": "Painting",
  "hasImage": true,
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** A handful of departments have few or no CC0 images. If you select such a department with `hasImage` on, expect a small or empty result set. Turn `hasImage` off to browse catalog records without images.

### 📊 Output

Each artwork becomes one record. The headline image URL is always first, `scrapedAt` is second to last, and `error` is always last.

| Field | Description |
|---|---|
| 🖼 `imageUrl` | CC0 web image URL (falls back to print, then full). |
| 📌 `title` | Artwork title. |
| 🔗 `url` | Canonical museum page for the object. |
| 🆔 `id` | Numeric object id. |
| 🏷 `accessionNumber` | Museum accession number. |
| 🎨 `artist` | Primary creator with nationality and life dates. |
| 📅 `creationDate` | Display creation date as published. |
| 🏛 `type` | Object type, for example Painting. |
| 🧪 `medium` | Technique or medium. |
| 📐 `measurements` | Framed and unframed dimensions. |
| 🗂 `department` | Curatorial department. |
| 📚 `collection` | Internal collection grouping. |
| 🌍 `culture` | Culture and period tags. |
| 🧾 `creditLine` | Credit line for the acquisition. |
| 📜 `shareLicenseStatus` | License status, typically CC0. |
| 📍 `currentLocation` | Current gallery or location. |
| 👥 `creators` | Full creators list with roles and life years. |
| 🖨 `printImageUrl` | Higher resolution print image URL. |
| 🕒 `scrapedAt` | Timestamp when the record was collected. |
| ❌ `error` | Null on success, message on failure. |

Real sample records from a live run:

```json
[
  {
    "imageUrl": "https://openaccess-cdn.clevelandart.org/1915.534/1915.534_web.jpg",
    "title": "Nathaniel Hurd",
    "url": "https://clevelandart.org/art/1915.534",
    "id": 94979,
    "accessionNumber": "1915.534",
    "artist": "John Singleton Copley (American, 1738–1815)",
    "creationDate": "c. 1765",
    "type": "Painting",
    "medium": "oil on canvas",
    "department": "American Painting and Sculpture",
    "culture": ["America"],
    "shareLicenseStatus": "CC0",
    "scrapedAt": "2026-06-05T17:42:59.000Z",
    "error": null
  },
  {
    "imageUrl": "https://openaccess-cdn.clevelandart.org/1922.1133/1922.1133_web.jpg",
    "title": "Stag at Sharkey's",
    "url": "https://clevelandart.org/art/1922.1133",
    "id": 94980,
    "accessionNumber": "1922.1133",
    "artist": "George Bellows (American, 1882–1925)",
    "creationDate": "1909",
    "type": "Painting",
    "medium": "oil on canvas",
    "department": "American Painting and Sculpture",
    "culture": ["America"],
    "shareLicenseStatus": "CC0",
    "scrapedAt": "2026-06-05T17:42:59.000Z",
    "error": null
  },
  {
    "imageUrl": "https://openaccess-cdn.clevelandart.org/1927.1984/1927.1984_web.jpg",
    "title": "The Biglin Brothers Turning the Stake",
    "url": "https://clevelandart.org/art/1927.1984",
    "id": 94981,
    "accessionNumber": "1927.1984",
    "artist": "Thomas Eakins (American, 1844–1916)",
    "creationDate": "1873",
    "type": "Painting",
    "medium": "oil on canvas",
    "department": "American Painting and Sculpture",
    "culture": ["America"],
    "shareLicenseStatus": "CC0",
    "scrapedAt": "2026-06-05T17:42:59.000Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

- Built directly on the museum's official Open Access API, so the data is first party.
- Image first records, ready to drop into a gallery, model pipeline, or catalog.
- CC0 means the images are public domain and free to reuse.
- Clean flat fields plus the full creators list when you need more detail.
- Sensible defaults, so a single run returns image-backed works out of the box.

### 📈 How it compares to alternatives

| Approach | Image URLs | Structured fields | Setup effort | Public domain clarity |
|---|---|---|---|---|
| This Actor | Yes, CC0 web and print | 19 fields per record | Point and run | CC0 surfaced per record |
| Manual API calls | Yes | You parse it yourself | High | You check each object |
| Web scraping the site | Fragile | Inconsistent | High | Unclear |
| Screenshotting pages | No clean URL | None | Very high | Unclear |

### 🚀 How to use

1. Create a free Apify account with our [sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Cleveland Museum of Art Scraper.
3. Set a `query`, pick a `department` or `type`, or leave everything empty to browse.
4. Set `maxItems` and click Start.
5. Download your results or connect them to the integrations below.

### 💼 Business use cases

**Product and design teams**

| Need | How this helps |
|---|---|
| Royalty free imagery | CC0 image URLs ready for products and decks |
| Mood boards and themes | Filter by department or culture for curated sets |

**Data and machine learning**

| Need | How this helps |
|---|---|
| Training data | Public domain art with labeled medium, type, and date |
| Metadata enrichment | Map accession numbers to clean structured records |

**Education and publishing**

| Need | How this helps |
|---|---|
| Course materials | Pull works by artist or period for lessons |
| Catalog content | Populate articles and guides with sourced facts |

**Research and GLAM**

| Need | How this helps |
|---|---|
| Collection analysis | Slice the collection by department, culture, or type |
| Provenance work | Keep credit line, accession number, and museum URL together |

### 🔌 Automating Cleveland Museum of Art Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** for no code workflows.
- **Slack** to post new finds to a channel.
- **Airbyte** to load records into a warehouse.
- **GitHub** to trigger runs from a repository action.
- **Google Drive** to archive results.

### 🌟 Beyond business use cases

- **Research:** study an artist or period across the open collection.
- **Personal:** build a wallpaper or print set from public domain art.
- **Non-profit:** source imagery for community and museum projects.
- **Experimentation:** prototype art search, tagging, or recommendation tools.

### 🤖 Ask an AI assistant

Paste your results 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 summarize trends, group works by theme, or draft captions.

### ❓ Frequently Asked Questions

**Is the data really free to use?**
The records flagged CC0 are released into the public domain by the museum. Always confirm the `shareLicenseStatus` on each record before reuse.

**Where does the data come from?**
From the Cleveland Museum of Art Open Access API, the museum's own published endpoint.

**Do I need an API key?**
No. The Open Access API is keyless.

**Can I get only artworks with images?**
Yes. Keep `hasImage` on, which is the default.

**How do I filter by department?**
Use the `department` select field. Each value maps to a real curatorial department.

**Can I search by artist?**
Yes. Put the artist name in `query`, for example monet or eakins.

**What image resolutions are available?**
The web image is in `imageUrl` and a larger print image is in `printImageUrl`.

**How many records can I get?**
Free runs return up to 10. Paid plans go far higher, up to the collection size.

**What if an artwork has no image?**
With `hasImage` off, image fields may be null for catalog only objects.

**Is this affiliated with the museum?**
No. It is an independent tool that reads publicly available open access data.

### 🔌 Integrate with any app

Every run produces a structured dataset you can pull through the Apify API or push to Make, Zapier, Airbyte, Slack, Google Drive, and more.

### 🔗 Recommended Actors

- [Nobel Prize Laureates Scraper](https://apify.com/parseforge)
- [Gaia Star Catalog Scraper](https://apify.com/parseforge)
- [Paleobiology Fossils Scraper](https://apify.com/parseforge)
- [SIMBAD Astronomical Objects 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 Cleveland Museum of Art. Only publicly available open access data is collected.

# Actor input Schema

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

Free text search across titles, artists, and descriptions. Example: monet, samurai, landscape. Leave empty to browse the whole open access collection.

## `department` (type: `string`):

Limit results to a single curatorial department.

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

Limit results to a single object type. Example: Painting, Drawing, Print, Sculpture, Textile, Photograph.

## `hasImage` (type: `boolean`):

When enabled, only artworks that carry a CC0 image are returned. Recommended, since image URLs are the headline field.

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

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

## Actor input object example

```json
{
  "hasImage": true,
  "maxItems": 10
}
```

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/cleveland-museum-of-art-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 = { "maxItems": 10 }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cleveland Museum of Art Scraper",
        "description": "Search the Cleveland Museum of Art open access collection for public domain artworks. Pull CC0 image URLs, title, artist, creation date, medium, dimensions, department, and culture. Great for art research, machine learning datasets, and building galleries or catalogs.",
        "version": "0.1",
        "x-build-id": "pJRHzng3CAIKEiait"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~cleveland-museum-of-art-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-cleveland-museum-of-art-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~cleveland-museum-of-art-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-cleveland-museum-of-art-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~cleveland-museum-of-art-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-cleveland-museum-of-art-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 titles, artists, and descriptions. Example: monet, samurai, landscape. Leave empty to browse the whole open access collection."
                    },
                    "department": {
                        "title": "Department",
                        "enum": [
                            "African Art",
                            "American Painting and Sculpture",
                            "Art of the Americas",
                            "Chinese Art",
                            "Decorative Art and Design",
                            "Drawings",
                            "Egyptian and Ancient Near Eastern Art",
                            "European Painting and Sculpture",
                            "Greek and Roman Art",
                            "Islamic Art",
                            "Japanese Art",
                            "Korean Art",
                            "Medieval Art",
                            "Modern European Painting and Sculpture",
                            "Oceania",
                            "Photography",
                            "Prints",
                            "Textiles"
                        ],
                        "type": "string",
                        "description": "Limit results to a single curatorial department."
                    },
                    "type": {
                        "title": "Object Type",
                        "type": "string",
                        "description": "Limit results to a single object type. Example: Painting, Drawing, Print, Sculpture, Textile, Photograph."
                    },
                    "hasImage": {
                        "title": "Only Artworks With Images",
                        "type": "boolean",
                        "description": "When enabled, only artworks that carry a CC0 image are returned. Recommended, since image URLs are the headline field.",
                        "default": true
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
