# Hugging Face Collections Scraper (`automation-lab/huggingface-collections-scraper`) Actor

Scrape Hugging Face curated collections of AI models, datasets & spaces. Browse trending, top-voted or filter by organization. No API key required.

- **URL**: https://apify.com/automation-lab/huggingface-collections-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

## Hugging Face Collections Scraper

Extract curated collections of AI models, datasets, and spaces from Hugging Face — trending, top-voted, or filtered by organization. No API key required.

### 🤔 What does it do?

This actor scrapes [Hugging Face Collections](https://huggingface.co/collections) — curated groupings of models, datasets, and spaces organized by researchers, companies, and the community. You can:

- 🔥 Browse **trending** or **most-upvoted** public collections
- 👤 Fetch all collections from a specific **user or organization** (e.g., Google, Meta, Mistral AI)
- 🔗 Retrieve **specific collections by slug** for targeted extraction

For each collection, you get the title, description, owner info, upvotes, theme, all contained items (model/dataset/space IDs, types, authors, likes, downloads), and more.

The actor calls the official HuggingFace public API — no login, no API key, no browser automation required.

### 👥 Who is it for?

#### 🧑‍🔬 AI Researchers & Data Scientists
Monitor which model collections are gaining traction in the community. Track when leading labs (Google, Meta, Mistral, Cohere) publish new curated groupings of models. Use collection membership as a signal for quality filtering.

#### 🏢 Enterprise AI Teams
Audit what models competitors have curated. Build automated pipelines to import model metadata from industry-relevant collections into your internal model registry or catalog.

#### 📊 Market Intelligence Analysts
Track the AI ecosystem by monitoring trending collections over time. Identify which organizations are publishing the most influential model groupings. Measure upvote velocity as a proxy for community interest.

#### 🛠️ MLOps & Tooling Developers
Build collection-aware model discovery tools. Automatically fetch and sync collection contents into your model management platform. Power recommendation engines with social signals from HF collections.

### 💡 Why use this actor?

- **No authentication required** — Hugging Face Collections API is fully public
- **Fast & cheap** — pure HTTP, no browser overhead, near-zero compute cost
- **Pagination handled** — automatically follows cursor-based pagination to fetch any number of collections
- **Multiple modes** — browse globally, filter by owner, or fetch specific slugs
- **Structured output** — each item in a collection includes type, author, likes, downloads, pipeline tag

### 📦 Data extracted

| Field | Description |
|-------|-------------|
| `slug` | Unique collection identifier (e.g., `google/gemma-2-...`) |
| `title` | Collection display title |
| `description` | Collection description |
| `ownerName` | HuggingFace username or org |
| `ownerType` | `user` or `org` |
| `ownerUrl` | Link to owner's HF profile |
| `collectionUrl` | Full URL to the collection |
| `upvotes` | Number of upvotes |
| `theme` | Collection theme color |
| `private` | Whether private |
| `gating` | Whether gated access |
| `lastUpdated` | ISO timestamp of last update |
| `itemCount` | Number of items in collection |
| `itemTypes` | Comma-separated item types (model, dataset, space) |
| `items` | Array of collection items with id, type, author, likes, downloads, pipelineTag |
| `scrapedAt` | Extraction timestamp |

### 💰 How much does it cost to scrape Hugging Face collections?

This actor uses **Pay-Per-Event (PPE)** pricing — you pay only for what you extract.

| Tier | Start fee | Per collection |
|------|-----------|----------------|
| FREE | $0.001 | $0.00115 |
| BRONZE | $0.001 | $0.001 |
| SILVER | $0.001 | $0.00078 |
| GOLD | $0.001 | $0.0006 |
| PLATINUM | $0.001 | $0.0004 |
| DIAMOND | $0.001 | $0.00028 |

**Example costs (BRONZE tier):**
- 20 trending collections → ~$0.021
- 100 collections from Meta → ~$0.101
- 500 top collections → ~$0.501

With a free Apify account (up to $5 free compute/month), you can extract approximately **4,000+ collections per month** at no cost.

### 🚀 How to use

#### Step 1 — Choose your mode

Select from three scraping modes:

- **Browse** — gets trending or most-voted public collections
- **Owner** — fetches all collections by a specific user or organization
- **Slugs** — retrieves exact collections you specify

#### Step 2 — Configure limits

Set `maxCollections` to control how many collections to extract. Default is 100.

#### Step 3 — Run and export

Click **Start** and wait for results. Export to JSON, CSV, or connect to downstream workflows.

### ⚙️ Input parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `mode` | string | `browse`, `owner`, or `slugs` | `browse` |
| `sort` | string | `trending` or `upvotes` (browse mode only) | `trending` |
| `owner` | string | Username or org name (owner mode only) | — |
| `collectionSlugs` | array | List of collection slugs (slugs mode only) | `[]` |
| `maxCollections` | integer | Max collections to extract | `100` |
| `includeItems` | boolean | Include item details in output | `true` |
| `maxRequestRetries` | integer | Retry attempts per failed request | `3` |

#### Example inputs

**Browse trending collections:**
```json
{
  "mode": "browse",
  "sort": "trending",
  "maxCollections": 50
}
````

**Collections from a specific organization:**

```json
{
  "mode": "owner",
  "owner": "google",
  "maxCollections": 100
}
```

**Fetch specific collections:**

```json
{
  "mode": "slugs",
  "collectionSlugs": [
    "google/gemma-2-665d5624d9e0312f5dfb1a1a",
    "meta-llama/llama-3-1-669233f0b30c5aa8b7b40b52"
  ]
}
```

### 📤 Output example

```json
{
  "slug": "google/gemma-2-665d5624d9e0312f5dfb1a1a",
  "title": "Gemma 2",
  "description": "Google's Gemma 2 open models collection.",
  "ownerName": "google",
  "ownerType": "org",
  "ownerUrl": "https://huggingface.co/google",
  "collectionUrl": "https://huggingface.co/collections/google/gemma-2-665d5624d9e0312f5dfb1a1a",
  "upvotes": 1245,
  "theme": "blue",
  "private": false,
  "gating": false,
  "lastUpdated": "2025-12-01T10:00:00.000Z",
  "itemCount": 5,
  "itemTypes": "model",
  "items": [
    {
      "id": "google/gemma-2-2b",
      "type": "model",
      "author": "google",
      "position": 0,
      "likes": 1892,
      "downloads": 554321,
      "pipelineTag": "text-generation",
      "lastModified": "2025-11-20T08:00:00.000Z"
    }
  ],
  "scrapedAt": "2026-05-04T12:00:00.000Z"
}
```

### 💡 Tips & tricks

- **Use `sort: "upvotes"` for quality signals** — collections with many upvotes tend to contain high-quality, vetted models
- **Owner mode is ideal for competitive intelligence** — fetch all collections from `google`, `meta-llama`, `mistralai`, `cohere` regularly
- **Disable `includeItems` for fast metadata-only runs** — useful when you just need collection counts and upvote rankings
- **Slugs mode for targeted monitoring** — watch specific high-value collections (e.g., official Llama 3 collection) for new additions
- **Combine with HuggingFace Models Scraper** — use collection item IDs as seeds to fetch full model details

### 🔌 Integrations

#### Google Sheets — AI model tracking dashboard

Use the Apify Google Sheets integration to append trending collection data weekly. Build a dashboard tracking which organizations are publishing new model groupings and their upvote velocity.

#### Slack alerts on new trending collections

Chain this actor with Slack integration to send a weekly digest of top trending collections. Set `maxCollections: 10` and `sort: trending` as the alert input.

#### Model catalog enrichment pipeline

Run this actor nightly for a curated list of organization slugs. Feed the output into your internal model registry to automatically tag models that appear in official company collections.

#### Make / Zapier automation

Use collection membership changes to trigger downstream workflows — e.g., automatically download or evaluate newly added models when a watched collection is updated.

### 🖥️ API usage

#### Node.js (Apify SDK)

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

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

const run = await client.actor('automation-lab/huggingface-collections-scraper').call({
    mode: 'browse',
    sort: 'trending',
    maxCollections: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_API_TOKEN")

run = client.actor("automation-lab/huggingface-collections-scraper").call(run_input={
    "mode": "owner",
    "owner": "google",
    "maxCollections": 100,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["upvotes"])
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~huggingface-collections-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "browse",
    "sort": "upvotes",
    "maxCollections": 100
  }'
```

### 🤖 MCP (Claude, Cursor, VS Code)

Use this actor directly from AI assistants via the Apify MCP server.

**Claude Code:**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/huggingface-collections-scraper"
```

**Claude Desktop / Cursor / VS Code** — add to your MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/huggingface-collections-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}
```

**Example prompts:**

- "Fetch the top 20 trending Hugging Face collections and list them by upvotes"
- "Get all collections published by google on HuggingFace"
- "Scrape the Llama 3 collection from meta-llama and show me the models it contains"

### ⚖️ Legality & terms of service

This actor uses Hugging Face's **public API** (`huggingface.co/api/collections`), which is freely accessible without authentication and intended for programmatic access. All data returned is publicly visible on the HuggingFace website.

- Only public collections are accessible
- Private or gated collections cannot be accessed
- No login credentials are used or stored
- Respects the public API rate limits
- Use responsibly in accordance with [Hugging Face Terms of Service](https://huggingface.co/terms-of-service)

### ❓ FAQ

**Q: Do I need a Hugging Face API key?**
No. The Collections API is fully public and requires no authentication.

**Q: Can I scrape private collections?**
No. The public API only returns public collections. Private collections require HF authentication which this actor does not support.

**Q: How many collections can I extract?**
Theoretically unlimited — the actor paginates through all available results. In practice, HuggingFace has tens of thousands of public collections.

**Q: Why am I getting fewer results than expected?**
Some owners may have no public collections, or the keyword may match fewer collections than your `maxCollections` limit. Check the actor logs for details.

**Q: The actor ran but returned 0 results — what happened?**
For owner mode, verify the username/org name is correct (case-sensitive, e.g., `google` not `Google`). For slugs mode, verify the full slug including the owner prefix (e.g., `google/gemma-2-abc123`).

**Q: Can I get the full model details for items in a collection?**
This actor returns the core item metadata (ID, type, author, likes, downloads). For full model cards and metadata, use the [Hugging Face Models Scraper](https://apify.com/automation-lab/huggingface-scraper) with the model IDs as input.

### 🔗 Related scrapers

- [Hugging Face Scraper](https://apify.com/automation-lab/huggingface-scraper) — scrape model cards, parameters, and full metadata
- [Hugging Face Datasets Scraper](https://apify.com/automation-lab/huggingface-datasets-scraper) — extract dataset metadata and download links
- [Hugging Face Papers Scraper](https://apify.com/automation-lab/huggingface-papers-scraper) — scrape ML research papers with AI summaries
- [Hugging Face Spaces Scraper](https://apify.com/automation-lab/huggingface-spaces-scraper) — discover and extract AI demo spaces

# Actor input Schema

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

Choose how to find collections. 'browse' gets trending or top-voted collections. 'owner' gets collections from a specific user/org. 'slugs' fetches specific collections by their slugs.

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

Sort collections by trending activity or total upvotes. Used in 'browse' mode.

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

Hugging Face username or organization name to scrape collections from (e.g. 'google', 'meta-llama'). Used in 'owner' mode.

## `collectionSlugs` (type: `array`):

List of collection slugs to fetch (e.g. 'google/gemma-2-665d5624d9e0312f5dfb1a1a'). Used in 'slugs' mode.

## `maxCollections` (type: `integer`):

Maximum number of collections to extract.

## `includeItems` (type: `boolean`):

Include the list of models/datasets/spaces in each collection. Disable to get collection metadata only (faster).

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed API requests.

## Actor input object example

```json
{
  "mode": "browse",
  "sort": "trending",
  "collectionSlugs": [],
  "maxCollections": 20,
  "includeItems": true,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "mode": "browse",
    "sort": "trending",
    "owner": "",
    "collectionSlugs": [],
    "maxCollections": 20,
    "includeItems": true,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/huggingface-collections-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 = {
    "mode": "browse",
    "sort": "trending",
    "owner": "",
    "collectionSlugs": [],
    "maxCollections": 20,
    "includeItems": True,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/huggingface-collections-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 '{
  "mode": "browse",
  "sort": "trending",
  "owner": "",
  "collectionSlugs": [],
  "maxCollections": 20,
  "includeItems": true,
  "maxRequestRetries": 3
}' |
apify call automation-lab/huggingface-collections-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/huggingface-collections-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hugging Face Collections Scraper",
        "description": "Scrape Hugging Face curated collections of AI models, datasets & spaces. Browse trending, top-voted or filter by organization. No API key required.",
        "version": "0.1",
        "x-build-id": "Ato0oaTgKCKXEuYJU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~huggingface-collections-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-huggingface-collections-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~huggingface-collections-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-huggingface-collections-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~huggingface-collections-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-huggingface-collections-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Scraping mode",
                        "enum": [
                            "browse",
                            "owner",
                            "slugs"
                        ],
                        "type": "string",
                        "description": "Choose how to find collections. 'browse' gets trending or top-voted collections. 'owner' gets collections from a specific user/org. 'slugs' fetches specific collections by their slugs.",
                        "default": "browse"
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "trending",
                            "upvotes"
                        ],
                        "type": "string",
                        "description": "Sort collections by trending activity or total upvotes. Used in 'browse' mode.",
                        "default": "trending"
                    },
                    "owner": {
                        "title": "Owner username or org",
                        "type": "string",
                        "description": "Hugging Face username or organization name to scrape collections from (e.g. 'google', 'meta-llama'). Used in 'owner' mode."
                    },
                    "collectionSlugs": {
                        "title": "Collection slugs",
                        "type": "array",
                        "description": "List of collection slugs to fetch (e.g. 'google/gemma-2-665d5624d9e0312f5dfb1a1a'). Used in 'slugs' mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCollections": {
                        "title": "Max collections",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of collections to extract.",
                        "default": 100
                    },
                    "includeItems": {
                        "title": "Include collection items",
                        "type": "boolean",
                        "description": "Include the list of models/datasets/spaces in each collection. Disable to get collection metadata only (faster).",
                        "default": true
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed API requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```