# HuggingFace Models Scraper (`solidcode/huggingface-co-scraper`) Actor

\[💰 $1.00 / 1K] Extract model metadata from the HuggingFace Hub — downloads, likes, trending score, task, library, license, tags, dates, and file lists. Search by keyword, filter by author, task, library, or tag, and sort by popularity or date.

- **URL**: https://apify.com/solidcode/huggingface-co-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** AI, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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

## HuggingFace Models Scraper

Pull structured model metadata from the HuggingFace Hub at scale — all-time downloads, likes, trending scores, task, framework, license, gated-access status, and the full repository file manifest for any model across the Hub's 1M+ open-source repositories. Built for ML engineers, AI researchers, and data teams who need to track the open-model ecosystem in a clean spreadsheet without clicking through the Hub one model card at a time.

### Why This Scraper?

- **26 machine-learning task filters** — narrow to Text Generation, Speech Recognition (ASR), Text-to-Image, Feature Extraction (Embeddings), Object Detection, and 21 more, each from a plain-English dropdown instead of raw API strings.
- **17 framework & format filters** — pinpoint models by Transformers, Diffusers, GGUF, Safetensors, ONNX, PEFT (LoRA / adapters), Sentence Transformers, MLX (Apple), and 9 others.
- **All-time downloads, likes, and Hub trending score on every row** — the three adoption signals you need to rank models by real-world traction, not guesswork.
- **License extracted for every model** — `apache-2.0`, `mit`, `llama3.1`, `cc-by-nc-4.0`, and more, pulled from model card data so you can filter by what you're legally allowed to ship.
- **Gated-access status detection** — each model is flagged `open`, `auto`, or `manual` so you know upfront which weights need an access request before download.
- **Full repository file manifest on demand** — flip one switch to list every weight, config, tokenizer, and README file per repo, ideal for auditing which models publish GGUF or Safetensors artifacts.
- **AND-semantics multi-tag filtering** — stack arbitrary Hub tags (`gguf`, `merge`, `conversational`, `code`) and get back only models that carry every one.
- **5 sort modes** — order by trending score, all-time downloads, likes, last-modified, or creation date, with oldest-first paging supported for creation date.
- **Up to 50,000 models per run** — sweep an entire task, author, or framework in a single pass across the Hub's 1M+ models.

### Use Cases

**Model Selection & ML Ops**
- Shortlist the top text-generation models by downloads before a fine-tuning project
- Filter to a framework your stack supports (Transformers, ONNX, GGUF) to avoid conversion work
- Screen out gated models when you need weights available for automated pipelines
- Compare license terms across candidate models to confirm commercial use is allowed

**Market & Competitive Research**
- Track every model an organization (`meta-llama`, `google`, `mistralai`) has published
- Measure adoption of a model family by all-time download and like counts
- Benchmark your own released models against competitors in the same task category
- Map which frameworks dominate a given ML task across the Hub

**Trend Monitoring**
- Pull the trending leaderboard for any task to catch rising models early
- Sort by creation date to surface the newest releases in embeddings or speech
- Watch download velocity on a fixed model set over repeated runs
- Spot new GGUF or MLX quantizations as they appear via tag filters

**Dataset & Leaderboard Building**
- Assemble a structured catalog of models for internal discovery tools
- Feed a model registry or evaluation harness with fresh metadata
- Build ranked leaderboards by downloads, likes, or trending score
- Power a searchable index of open models for your team

**Compliance & License Auditing**
- Audit which models in a shortlist carry non-commercial or share-alike licenses
- Flag gated models that require an access agreement before use
- Inventory repository file types to confirm required artifacts (weights, configs) are published
- Document provenance — author, creation date, and last-modified timestamp per model

### Getting Started

#### Search by Keyword

The simplest run — just a search term:

```json
{
    "search": "llama",
    "maxResults": 100
}
````

#### Filter by Task and Framework

Combine a task and a framework to get exactly the models your stack can run:

```json
{
    "pipelineTag": "text-generation",
    "libraryName": "gguf",
    "sortBy": "downloads",
    "maxResults": 500
}
```

#### One Organization's Full Catalog

Pull every model an organization has published, newest first:

```json
{
    "author": "mistralai",
    "sortBy": "createdAt",
    "sortDirection": "descending",
    "maxResults": 1000
}
```

#### Advanced — Tagged, Sorted, with File Lists

```json
{
    "search": "embedding",
    "pipelineTag": "sentence-similarity",
    "libraryName": "sentence-transformers",
    "tags": ["safetensors"],
    "sortBy": "likes",
    "sortDirection": "descending",
    "maxResults": 2000,
    "includeFiles": true
}
```

### Input Reference

#### Search & Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `search` | string | `"llama"` | Free-text search across model names and descriptions. Leave empty to browse all models by the filters and sort order below. |
| `author` | string | `null` | Only include models from this user or organization (e.g. `meta-llama`, `google`, `mistralai`). |
| `pipelineTag` | select | `null` | Only include models built for one machine-learning task. 26 options including Text Generation, Text Classification, Speech Recognition (ASR), Text-to-Image, Feature Extraction (Embeddings), and Object Detection. |
| `libraryName` | select | `null` | Only include models built with one framework or file format. 17 options including Transformers, Diffusers, GGUF, Safetensors, ONNX, PEFT (LoRA / adapters), and MLX (Apple). |
| `tags` | string\[] | `[]` | Extra Hub tags a model must have (e.g. `gguf`, `merge`, `conversational`, `code`). A model is included only if it has every tag you list. |

#### Results

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Trending` | Order results by Trending, Most downloads, Most likes, Recently updated, or Recently created. |
| `sortDirection` | select | `Descending (highest / newest first)` | Order direction. The Hub only supports ascending order for "Recently created"; every other sort always returns highest/newest first. |
| `maxResults` | integer | `100` | Maximum number of models to return. Set to 0 to fetch all matches, bounded by a 50,000-model safety cap. |
| `includeFiles` | boolean | `false` | Add each model's repository file list (weights, configs, tokenizer files, README) to the output. Turn off for a lighter, faster result. |

### Output

Each model is one flat row. Here's a representative result with `includeFiles` enabled:

```json
{
    "id": "meta-llama/Llama-3.1-8B-Instruct",
    "author": "meta-llama",
    "modelName": "Llama-3.1-8B-Instruct",
    "url": "https://huggingface.co/meta-llama/Llama-3.1-8B-Instruct",
    "pipelineTag": "text-generation",
    "libraryName": "transformers",
    "license": "llama3.1",
    "downloads": 4821337,
    "likes": 3894,
    "trendingScore": 42,
    "tags": ["transformers", "safetensors", "llama", "conversational", "license:llama3.1"],
    "gated": "manual",
    "private": false,
    "createdAt": "2024-07-18T16:57:41.000Z",
    "lastModified": "2024-09-25T17:00:57.000Z",
    "sha": "0e9e39f249a16976918f6564b8830bc894c89659",
    "files": ["config.json", "model-00001-of-00004.safetensors", "tokenizer.json", "README.md"],
    "scrapedAt": "2026-07-03T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Full model id in `author/name` form (e.g. `meta-llama/Llama-3.1-8B-Instruct`). |
| `author` | string | null | Owning user or organization. |
| `modelName` | string | null | Name portion after the last `/`. |
| `url` | string | null | Canonical model page URL on the Hub. |
| `private` | boolean | Whether the repository is private. |
| `scrapedAt` | string | ISO timestamp when the row was fetched. |

#### Classification

| Field | Type | Description |
|-------|------|-------------|
| `pipelineTag` | string | null | Primary machine-learning task (e.g. `text-generation`). |
| `libraryName` | string | null | Framework or format the model is built with (e.g. `transformers`). |
| `license` | string | null | License id from card data (e.g. `apache-2.0`, `mit`, `llama3.1`). |
| `tags` | string\[] | All Hub tags — task, language, `dataset:`, `arxiv:`, `license:`, `region:`, and more. |
| `gated` | boolean | string | Gated-access status: `false` (open), `"auto"`, or `"manual"`. |

#### Metrics

| Field | Type | Description |
|-------|------|-------------|
| `downloads` | integer | null | All-time download count. |
| `likes` | integer | null | Like count. |
| `trendingScore` | number | null | Hub trending score. |

#### Dates & Files

| Field | Type | Description |
|-------|------|-------------|
| `createdAt` | string | null | ISO creation timestamp. |
| `lastModified` | string | null | ISO last-modified timestamp. |
| `sha` | string | null | Latest commit SHA. |
| `files` | string\[] | null | Repository file names — populated only when `includeFiles` is on, otherwise `null`. |

### Tips for Best Results

- **Start with a small `maxResults`** — run 50–100 first to confirm the filters match what you want, then scale up to thousands.
- **Combine `pipelineTag` and `libraryName`** — pairing a task with a framework (e.g. Text Generation + GGUF) is the fastest way to a short, highly relevant list instead of sifting a broad search.
- **Page the oldest models first** — set `sortBy` to `Recently created` with `sortDirection` ascending to walk a task's history from its very first release forward; this ascending order is only supported on creation date.
- **Turn on `includeFiles` for artifact audits** — the file list reveals which repos ship GGUF, Safetensors, or ONNX weights, so you can filter deployable models without opening each card.
- **Leave `search` empty to browse by filters alone** — an author, task, or tag combination with no search term returns the full matching set in your chosen sort order.
- **Stack `tags` for precision** — every tag you add tightens the result set (all must match), so use it to isolate niche subsets like `merge` or `conversational`.
- **Sort by downloads for battle-tested picks, trending for what's rising** — downloads reward proven adoption, while trending surfaces momentum before a model is widely known.

### Pricing

**From $1.00 per 1,000 results** — a flat rate that makes sweeping an entire task category or organization's catalog affordable. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.12 | $0.115 | $0.105 | $0.10 |
| 1,000 | $1.20 | $1.15 | $1.05 | $1.00 |
| 10,000 | $12.00 | $11.50 | $10.50 | $10.00 |
| 100,000 | $120.00 | $115.00 | $105.00 | $100.00 |

A "result" is any model row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available model metadata from the HuggingFace Hub for legitimate research, model discovery, and market analysis. Users are responsible for complying with applicable laws and the HuggingFace Terms of Service. Respect each model's license terms and gated-access requirements before downloading or deploying any weights. Do not use extracted data for any unlawful purpose.

# Actor input Schema

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

Free-text search across model names and descriptions. Example: 'llama', 'whisper', 'stable diffusion'. Leave empty to browse all models by the filters and sort order below.

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

Only include models from this user or organization. Example: 'meta-llama', 'google', 'mistralai'.

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

Only include models built for this machine-learning task. Leave empty to include all tasks.

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

Only include models built with this framework or file format. Leave empty to include all libraries.

## `tags` (type: `array`):

Extra hub tags a model must have. Example: 'gguf', 'merge', 'conversational', 'code'. A model is included only if it has every tag you list here.

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

How to order the results.

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

Order direction. Descending puts the highest or newest values first. Note: the HuggingFace Hub only supports ascending order for 'Recently created' — for every other sort, results are always returned highest/newest first regardless of this setting.

## `maxResults` (type: `integer`):

Maximum number of models to return. Set to 0 to fetch all matches — in that case a safety cap of 50,000 models is applied so very broad searches don't run indefinitely (the Hub has over a million models).

## `includeFiles` (type: `boolean`):

Add each model's repository file list (weights, configs, tokenizer files, README) to the output. Turn off for a lighter, faster result.

## Actor input object example

```json
{
  "search": "llama",
  "tags": [],
  "sortBy": "trending",
  "sortDirection": "descending",
  "maxResults": 100,
  "includeFiles": false
}
```

# Actor output Schema

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

Table of models with author, task, library, downloads, likes, trending score, license, and links.

# 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",
    "tags": [],
    "sortBy": "trending",
    "sortDirection": "descending",
    "maxResults": 100,
    "includeFiles": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/huggingface-co-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",
    "tags": [],
    "sortBy": "trending",
    "sortDirection": "descending",
    "maxResults": 100,
    "includeFiles": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/huggingface-co-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",
  "tags": [],
  "sortBy": "trending",
  "sortDirection": "descending",
  "maxResults": 100,
  "includeFiles": false
}' |
apify call solidcode/huggingface-co-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HuggingFace Models Scraper",
        "description": "[💰 $1.00 / 1K] Extract model metadata from the HuggingFace Hub — downloads, likes, trending score, task, library, license, tags, dates, and file lists. Search by keyword, filter by author, task, library, or tag, and sort by popularity or date.",
        "version": "1.0",
        "x-build-id": "SZeXw3PcyQYa2aeTg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~huggingface-co-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-huggingface-co-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/solidcode~huggingface-co-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-huggingface-co-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/solidcode~huggingface-co-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-huggingface-co-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",
                        "type": "string",
                        "description": "Free-text search across model names and descriptions. Example: 'llama', 'whisper', 'stable diffusion'. Leave empty to browse all models by the filters and sort order below."
                    },
                    "author": {
                        "title": "Author or Organization",
                        "type": "string",
                        "description": "Only include models from this user or organization. Example: 'meta-llama', 'google', 'mistralai'."
                    },
                    "pipelineTag": {
                        "title": "Task",
                        "enum": [
                            "text-generation",
                            "text-classification",
                            "token-classification",
                            "question-answering",
                            "translation",
                            "summarization",
                            "feature-extraction",
                            "sentence-similarity",
                            "fill-mask",
                            "zero-shot-classification",
                            "text-to-image",
                            "image-to-text",
                            "image-classification",
                            "object-detection",
                            "image-segmentation",
                            "image-to-image",
                            "text-to-video",
                            "text-to-speech",
                            "automatic-speech-recognition",
                            "audio-classification",
                            "text-to-audio",
                            "image-text-to-text",
                            "visual-question-answering",
                            "reinforcement-learning",
                            "tabular-classification",
                            "tabular-regression"
                        ],
                        "type": "string",
                        "description": "Only include models built for this machine-learning task. Leave empty to include all tasks."
                    },
                    "libraryName": {
                        "title": "Library / Framework",
                        "enum": [
                            "transformers",
                            "diffusers",
                            "sentence-transformers",
                            "gguf",
                            "safetensors",
                            "peft",
                            "timm",
                            "onnx",
                            "keras",
                            "spacy",
                            "stable-baselines3",
                            "setfit",
                            "adapter-transformers",
                            "flair",
                            "espnet",
                            "nemo",
                            "mlx"
                        ],
                        "type": "string",
                        "description": "Only include models built with this framework or file format. Leave empty to include all libraries."
                    },
                    "tags": {
                        "title": "Additional Tags",
                        "type": "array",
                        "description": "Extra hub tags a model must have. Example: 'gguf', 'merge', 'conversational', 'code'. A model is included only if it has every tag you list here.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "trending",
                            "downloads",
                            "likes",
                            "lastModified",
                            "createdAt"
                        ],
                        "type": "string",
                        "description": "How to order the results.",
                        "default": "trending"
                    },
                    "sortDirection": {
                        "title": "Sort Direction",
                        "enum": [
                            "descending",
                            "ascending"
                        ],
                        "type": "string",
                        "description": "Order direction. Descending puts the highest or newest values first. Note: the HuggingFace Hub only supports ascending order for 'Recently created' — for every other sort, results are always returned highest/newest first regardless of this setting.",
                        "default": "descending"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of models to return. Set to 0 to fetch all matches — in that case a safety cap of 50,000 models is applied so very broad searches don't run indefinitely (the Hub has over a million models).",
                        "default": 100
                    },
                    "includeFiles": {
                        "title": "Include File List",
                        "type": "boolean",
                        "description": "Add each model's repository file list (weights, configs, tokenizer files, README) to the output. Turn off for a lighter, faster result.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
