# Hugging Face Models Scraper (`fetch_cat/hugging-face-models-scraper`) Actor

🤗 Scrape public Hugging Face model metadata, downloads, likes, tags, licenses, and update signals for AI market research.

- **URL**: https://apify.com/fetch\_cat/hugging-face-models-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** AI, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 model records

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

## Hugging Face Models Scraper

Track public Hugging Face model metadata, popularity, tags, licenses, and update signals from one clean Apify Actor.

### What does Hugging Face Models Scraper do?

Hugging Face Models Scraper collects public model catalog records from Hugging Face and saves normalized rows to an Apify dataset.
It is built for users who need repeatable model monitoring without manually browsing model pages.
You can search by keyword, filter by author, filter by task pipeline, filter by library, and sort by popularity or recency.

### Who is it for?

- 🤖 AI teams tracking model ecosystems and popular checkpoints.
- 📈 Market researchers measuring adoption of open-source models.
- 🧪 MLOps teams monitoring competitor model updates.
- 🧠 OSS intelligence teams watching licenses, tags, and download movement.
- 📰 Analysts building reports about AI model trends.

### Why use this actor?

The Hugging Face catalog changes constantly.
A scheduled scraper gives you repeatable snapshots, structured exports, and automation-ready data.
Instead of copying model names, likes, downloads, tags, and licenses by hand, run this actor and export JSON, CSV, Excel, or connect it to your workflow.

### Key features

- 🔎 Search public models by keyword.
- 👤 Limit results to an author or organization.
- 🧩 Filter by pipeline tag such as `text-generation`.
- 🛠️ Filter by library such as `transformers` or `diffusers`.
- 📊 Sort by downloads, likes, trending score, or last modified date.
- 🧾 Optional model-card metadata enrichment.
- 🔁 Pagination support for larger model lists.
- 📦 Clean one-row-per-model dataset output.

### What data can you extract?

| Field | Description |
| --- | --- |
| `modelId` | Full Hugging Face model ID. |
| `author` | Owner namespace or organization. |
| `name` | Model name without namespace. |
| `url` | Public model URL. |
| `likes` | Like count. |
| `downloads` | Download count reported by Hugging Face. |
| `trendingScore` | Trending score when available. |
| `tags` | Public tags for the model. |
| `pipelineTag` | Primary task / pipeline. |
| `libraryName` | Main library or framework. |
| `license` | License parsed from tags or card metadata. |
| `createdAt` | Creation timestamp. |
| `lastModified` | Last modification timestamp. |
| `private` | Private flag when reported. |
| `gated` | Gated-access flag when reported. |
| `sha` | Latest repository commit SHA. |
| `siblingsCount` | Number of repository files when available. |
| `cardData` | Optional model-card metadata. |

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `apify-actor-start` | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `item` | Per Hugging Face model record produced | $0.575 / 1,000 | $0.5 / 1,000 | $0.39 / 1,000 | $0.3 / 1,000 | $0.2 / 1,000 | $0.14 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### How to use Hugging Face Models Scraper

1. Open the actor on Apify.
2. Enter a search keyword such as `llama`, `bert`, or `stable diffusion`.
3. Optionally set an author such as `google`, `microsoft`, or `meta-llama`.
4. Optionally set a pipeline tag such as `text-generation`.
5. Choose a sort order.
6. Set a maximum number of models.
7. Run the actor.
8. Export the dataset or connect it to another system.

### Input options

#### Search query

Use `search` to find models by names and tags.
Examples:

- `llama`
- `bert`
- `speech recognition`
- `stable diffusion`
- `embedding`

#### Author / organization

Use `author` to focus on one Hugging Face namespace.
Examples:

- `google`
- `microsoft`
- `meta-llama`
- `stabilityai`
- `sentence-transformers`

#### Pipeline tag

Use `pipelineTag` to filter by task.
Examples:

- `text-generation`
- `image-classification`
- `text-to-image`
- `automatic-speech-recognition`
- `sentence-similarity`

#### Library / framework

Use `library` to filter by framework.
Examples:

- `transformers`
- `diffusers`
- `sentence-transformers`
- `timm`
- `pytorch`

#### Sort order

Choose one of:

- `downloads`
- `likes`
- `trending`
- `lastModified`

#### Maximum models

Set `limit` to control output size.
Start with 25 for a quick test.
Use larger values for monitoring or market research exports.

#### Include detail data

Enable `includeDetails` when you need richer model-card metadata.
This can add `cardData` and more complete file-count information.
It may take longer because the actor checks individual model records.

### Example input

```json
{
  "search": "llama",
  "pipelineTag": "text-generation",
  "sort": "downloads",
  "limit": 25,
  "includeDetails": false
}
````

### Example output

```json
{
  "modelId": "meta-llama/Llama-3.1-8B-Instruct",
  "author": "meta-llama",
  "name": "Llama-3.1-8B-Instruct",
  "url": "https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct",
  "likes": 6214,
  "downloads": 9489535,
  "trendingScore": 24,
  "tags": ["transformers", "text-generation"],
  "pipelineTag": "text-generation",
  "libraryName": "transformers",
  "license": "llama3.1",
  "createdAt": "2024-07-18T08:56:00.000Z",
  "lastModified": null,
  "private": false,
  "gated": false,
  "sha": "...",
  "siblingsCount": 12
}
```

### Tips for better results

- ✅ Use a specific keyword when you want focused results.
- ✅ Combine `author` and `pipelineTag` for organization-level monitoring.
- ✅ Sort by `lastModified` for update-monitoring workflows.
- ✅ Sort by `downloads` for popularity research.
- ✅ Turn on detail data only when you need richer metadata.

### Common use cases

#### Model popularity tracking

Run the actor daily or weekly with the same query and compare `downloads`, `likes`, and `trendingScore` over time.

#### Competitive intelligence

Track models from specific organizations and monitor releases, tags, and licenses.

#### License monitoring

Export `license` and `tags` fields to find models that match or conflict with your internal compliance policies.

#### AI catalog enrichment

Use `modelId`, `url`, `pipelineTag`, and `libraryName` to enrich internal model catalogs or discovery products.

### Integrations

Send results to Google Sheets, Slack, Make, Zapier, Airtable, BigQuery, Snowflake, or any system that accepts Apify dataset exports.
Use scheduled runs for recurring snapshots.
Use webhooks to trigger downstream processing when a scrape completes.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/hugging-face-models-scraper').call({
  search: 'llama',
  pipelineTag: 'text-generation',
  limit: 25
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/hugging-face-models-scraper').call(run_input={
    'search': 'llama',
    'pipelineTag': 'text-generation',
    'limit': 25,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~hugging-face-models-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"search":"llama","pipelineTag":"text-generation","limit":25}'
```

### MCP usage

Connect Apify MCP to Claude Desktop or Claude Code and enable this actor as a tool.
Use this MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/hugging-face-models-scraper
```

Claude Code setup example:

```bash
claude mcp add apify-hugging-face-models "https://mcp.apify.com/?tools=fetch_cat/hugging-face-models-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-hugging-face-models": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=fetch_cat/hugging-face-models-scraper"
      ]
    }
  }
}
```

Example prompts:

- "Find the top downloaded Hugging Face text-generation models for llama."
- "Track the latest models from google on Hugging Face."
- "Create a CSV of popular sentence-transformers models with licenses."

### Scheduling

Create an Apify schedule to run the same input daily, weekly, or monthly.
Scheduled snapshots are useful for trend dashboards and model-change monitoring.

### Data quality notes

The actor returns public metadata as reported by Hugging Face.
Some fields may be missing for certain models.
Gated models can still appear in public catalog data, but inaccessible private details are skipped.

### Limits

The input limit is capped to keep runs predictable.
Very broad searches can return many models, so choose a reasonable `limit` for your workflow.
If you need very large recurring exports, start with a small test run and then increase gradually.

### Troubleshooting

#### Why did I get fewer models than requested?

The selected filters may have fewer public results than your limit, or duplicate records may have been skipped.
Try a broader query or remove one filter.

#### Why is cardData missing?

`cardData` is included only when Hugging Face returns it.
Enable `includeDetails` for richer metadata, but remember detail runs take longer.

#### What if I see a rate-limit error?

Retry later or lower the limit.
For frequent monitoring, schedule smaller runs rather than one very large run.

### Legality

This actor collects publicly available metadata from Hugging Face.
Make sure your usage complies with Hugging Face terms, Apify terms, and applicable laws.
Do not use scraped data to violate model licenses or access restrictions.

### Related Apify actors

Explore related Apify actors from the same catalog:

- https://apify.com/fetch\_cat/github-repository-search-scraper
- https://apify.com/fetch\_cat/arxiv-paper-search-scraper
- https://apify.com/fetch\_cat/pubmed-search-scraper
- https://apify.com/fetch\_cat/product-hunt-scraper

### FAQ

#### Can I scrape private Hugging Face models?

No. This actor is designed for public model catalog metadata.

#### Can I filter by multiple authors at once?

Run the actor once per author or create multiple scheduled runs.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, and HTML.

#### Can I monitor changes over time?

Yes. Schedule repeated runs and compare datasets by `modelId`.

#### Does this actor download model files?

No. It collects metadata only.

#### Is browser automation used?

No customer action is needed; the actor is optimized for reliable metadata collection.

### Support

If a run fails or output looks wrong, open an issue with the run ID and the input you used.
Include the expected result and a sample model URL if possible.

# Actor input Schema

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

Keyword to match against public Hugging Face model names and tags. Example: llama, bert, speech, stable diffusion.

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

Optional Hugging Face namespace such as google, microsoft, meta-llama, openai, or stabilityai. Leave empty to search all authors.

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

Optional model task such as text-generation, image-classification, sentence-similarity, automatic-speech-recognition, or text-to-image.

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

Optional library tag such as transformers, diffusers, sentence-transformers, timm, or pytorch.

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

Choose how matching models are ordered before the limit is applied.

## `limit` (type: `integer`):

Maximum number of model records to save to the dataset. Keep this low for test runs.

## `includeDetails` (type: `boolean`):

Fetch each model detail endpoint to enrich cardData and file counts. This is slower but returns more complete metadata.

## Actor input object example

```json
{
  "search": "llama",
  "pipelineTag": "text-generation",
  "sort": "downloads",
  "limit": 20,
  "includeDetails": false
}
```

# 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 = {
    "search": "llama",
    "pipelineTag": "text-generation",
    "limit": 20,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/hugging-face-models-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 = {
    "search": "llama",
    "pipelineTag": "text-generation",
    "limit": 20,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/hugging-face-models-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 '{
  "search": "llama",
  "pipelineTag": "text-generation",
  "limit": 20,
  "includeDetails": false
}' |
apify call fetch_cat/hugging-face-models-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/hugging-face-models-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hugging Face Models Scraper",
        "description": "🤗 Scrape public Hugging Face model metadata, downloads, likes, tags, licenses, and update signals for AI market research.",
        "version": "0.1",
        "x-build-id": "T16dE3IaYxSojId7W"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~hugging-face-models-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-hugging-face-models-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/fetch_cat~hugging-face-models-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-hugging-face-models-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/fetch_cat~hugging-face-models-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-hugging-face-models-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": {
                    "search": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to match against public Hugging Face model names and tags. Example: llama, bert, speech, stable diffusion."
                    },
                    "author": {
                        "title": "Author / organization",
                        "type": "string",
                        "description": "Optional Hugging Face namespace such as google, microsoft, meta-llama, openai, or stabilityai. Leave empty to search all authors."
                    },
                    "pipelineTag": {
                        "title": "Pipeline tag",
                        "type": "string",
                        "description": "Optional model task such as text-generation, image-classification, sentence-similarity, automatic-speech-recognition, or text-to-image."
                    },
                    "library": {
                        "title": "Library / framework",
                        "type": "string",
                        "description": "Optional library tag such as transformers, diffusers, sentence-transformers, timm, or pytorch."
                    },
                    "sort": {
                        "title": "Sort models by",
                        "enum": [
                            "downloads",
                            "likes",
                            "trending",
                            "lastModified"
                        ],
                        "type": "string",
                        "description": "Choose how matching models are ordered before the limit is applied.",
                        "default": "downloads"
                    },
                    "limit": {
                        "title": "Maximum models",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of model records to save to the dataset. Keep this low for test runs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include detail data",
                        "type": "boolean",
                        "description": "Fetch each model detail endpoint to enrich cardData and file counts. This is slower but returns more complete metadata.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```