# YouTube Viral Video Finder – Outlier & Trend Radar (`lofomachines/youtube-viral-outlier-finder`) Actor

Find the videos that massively outperform their own channel's baseline in any niche. Outlier scores, view velocity, channel context and title patterns — no account, no API key.

- **URL**: https://apify.com/lofomachines/youtube-viral-outlier-finder.md
- **Developed by:** [Lofomachines](https://apify.com/lofomachines) (community)
- **Categories:** Social media, Videos, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## YouTube Viral Video Finder – Outlier Scores, Trends & Competitor Research

**Find the YouTube videos that are exploding right now — and know *why* they exploded.**

Most YouTube tools show you what is big. This one shows you what is **overperforming**. Every video is scored against the normal performance of the channel that published it, so a 200,000-view video on a 5,000-subscriber channel finally gets the attention it deserves — and a 200,000-view video on a channel that always does 2 million is correctly ignored.

That single number — the **outlier score** — is the difference between guessing what to make next and knowing.

> 🎯 Enter a topic. Get back every video in that niche that beat its own channel's baseline, ranked by how hard it beat it — with views, velocity, channel size, duration, tags, hook type and publishing day attached.

No YouTube account. No API key. No quotas. No login of any kind.

---

### ⚡ Why creators, agencies and brands run this every week

| Without it | With it |
| --- | --- |
| You scroll YouTube for hours looking for ideas | You get a ranked list of proven winners in 30 seconds |
| You copy what big channels do — and it flops | You copy what *worked beyond expectations*, at your channel size |
| You spot a trend when it is already saturated | You spot it while a 4,000-sub channel is quietly doing 500K views |
| You guess titles, lengths and posting days | You see the exact patterns behind the winners in your niche |
| You pay $30–$100/month for a subscription tool | You pay only for the scans you actually run |

---

### 📊 What you get for every video

Each row in your dataset is a complete intelligence file:

**Performance**
- `outlierScore` — how many times the video beat its own channel's normal performance
- `performanceTier` — viral / breakout / overperformer / normal / underperformer
- `views`, `channelBaselineViews`, `viewsPerDay`, `viewsPerSubscriber`
- `isSmallChannelBreakout` — the strongest possible signal that the **topic** is hot, not the channel
- `estimatedAdRevenueUsdLow` / `estimatedAdRevenueUsdHigh` — modelled earning range

**Video**
- Title, direct URL, thumbnail, full description, category and creator tags
- Exact publish timestamp, publishing weekday, age in days
- Duration in seconds and formatted, plus `format` (Shorts vs long-form)

**Channel context**
- Channel name, @handle, ID, URL, subscriber count, size tier
- Upload cadence (uploads per week) and how many uploads were used as the reference point

**Content patterns**
- `titleHookType` — how-to, listicle, question, challenge, comparison, warning, reveal, story
- Title length, word count, numbers, brackets, emojis, capitalisation ratio

**45 clean, consistently-typed fields per video.** Ready for Sheets, Airtable, Notion, a BI tool or your own model.

---

### 👥 Who this is for

- **YouTube creators** — never open a blank content calendar again
- **Faceless / automation channel operators** — find formats that are working *this week* at your channel size
- **Agencies & video editors** — build content strategies for clients backed by evidence, not opinion
- **Brands & social teams** — see which creators and formats own your category
- **Influencer marketing teams** — find creators whose reach is accelerating before their rates go up
- **Media & newsrooms** — catch stories going viral on YouTube before they hit anywhere else
- **Product & market researchers** — measure real audience demand for a topic, week over week
- **VCs and analysts** — track attention shifts in consumer categories

---

### 💡 Use cases

**1. Content ideation that actually converts**
Scan your niche for the last 30 days with the *Breakouts* filter. You get a shortlist of formats that beat expectations — not a list of famous channels.

**2. Weekly trend radar**
Schedule the Actor for every Monday with a 7-day window. Each run is a snapshot of what is accelerating. Compare runs to see topics rising and dying.

**3. Competitor teardown**
Drop 10 competitor channels in, set the window to 12 months, and instantly see which of their videos overperformed — the ones they are quietly building their whole strategy around.

**4. Title and thumbnail research**
Sort by outlier score, then read the `titleHookType`, `titleLength` and `titleHasNumber` columns. The packaging pattern behind the winners in your niche becomes obvious within one screen.

**5. Shorts strategy**
Switch the format to *Shorts only*. Short-form is compared only against short-form, so you get an honest read on which Shorts overperformed.

**6. Finding creators to sponsor**
Filter for `isSmallChannelBreakout`. These are channels with accelerating reach and rates that have not caught up yet.

**7. Validating a new channel or niche**
Before committing months of production, measure how much demand actually exists and how big the winners are relative to channel size.

**8. Best day and length to publish**
Aggregate `publishedDayOfWeek` and `durationSeconds` across the winners to see the cadence your niche rewards.

**9. Keyword and tag mining**
The `tags` field shows the exact terms the winning videos target — a direct feed into your own YouTube SEO.

**10. Client reporting**
Export to CSV or Excel and drop a ranked "what's working in your category" table into any deck.

---

### 🚀 How to use it

1. **Add your topics** — one per line, exactly how a viewer would search (`ai automation`, `sourdough bread`, `van build`).
2. **Optionally add channels** — `@handle` or a channel URL, to analyse specific competitors.
3. **Pick a time window, format and performance filter.** Hit Start.

Everything else is tuned automatically. There is nothing technical to configure.

#### Input example

```json
{
  "keywords": ["ai automation", "notion templates"],
  "channels": ["@veritasium"],
  "publishedWithin": "30d",
  "videoFormat": "all",
  "performanceFilter": "overperformers",
  "minViews": 1000,
  "region": "US",
  "maxResults": 200
}
````

| Field | What it does |
| --- | --- |
| `keywords` | Topics or niches to scan |
| `channels` | Optional competitor channels (`@handle` or URL) |
| `publishedWithin` | 24 hours → 12 months, or any time |
| `videoFormat` | All formats, long-form only, or Shorts only |
| `performanceFilter` | Everything, 2x, 5x or 10x the channel's normal views |
| `minViews` | Ignore videos below this view count |
| `region` | Audience market the scan should reflect |
| `maxResults` | How many scored videos to return |

#### Output example

```json
{
  "videoId": "hON6Fgjw5nc",
  "videoUrl": "https://www.youtube.com/watch?v=hON6Fgjw5nc",
  "title": "How I Fully Automated My Video Editing",
  "thumbnailUrl": "https://i.ytimg.com/vi/hON6Fgjw5nc/maxresdefault.jpg",
  "format": "long-form",
  "contentType": "video",
  "publishedAt": "2026-06-30T14:02:11.000Z",
  "publishedDate": "2026-06-30",
  "publishedDayOfWeek": "Tuesday",
  "daysSincePublished": 27,
  "durationSeconds": 964,
  "durationFormatted": "16:04",
  "views": 84526,
  "outlierScore": 70.44,
  "performanceTier": "viral",
  "channelBaselineViews": 1200,
  "viewsPerDay": 3130,
  "viewsPerSubscriber": 6.71,
  "isSmallChannelBreakout": true,
  "estimatedAdRevenueUsdLow": 338.1,
  "estimatedAdRevenueUsdHigh": 1521.47,
  "channelName": "Creator Studio Lab",
  "channelHandle": "@creatorstudiolab",
  "channelId": "UCui4jxDaMb53Gdh-AZUTPAg",
  "channelUrl": "https://www.youtube.com/channel/UCui4jxDaMb53Gdh-AZUTPAg",
  "channelSubscribers": 12600,
  "channelSizeTier": "small",
  "channelUploadsPerWeek": 1.4,
  "channelSampleSize": 28,
  "category": "Education",
  "tags": ["video editing", "ai automation", "content creation"],
  "tagCount": 18,
  "description": "In this video I break down the exact system...",
  "titleLength": 38,
  "titleWordCount": 6,
  "titleHookType": "story",
  "titleHasNumber": false,
  "titleHasQuestion": false,
  "titleIsListicle": false,
  "titleHasBrackets": false,
  "titleEmojiCount": 0,
  "titleUppercaseRatio": 0.08,
  "matchedQuery": "ai automation",
  "region": "US",
  "scannedAt": "2026-07-27T21:15:04.000Z"
}
```

Export as **JSON, CSV, Excel, XML or RSS**, or pull it straight from the API.

***

### 🔗 Integrations & automation

This Actor is built to sit inside a workflow, not just a browser tab.

- **n8n** — schedule a weekly scan, filter for `outlierScore > 10`, and push new ideas into Notion or Airtable automatically.
- **Make (Integromat)** — turn every breakout video into a card in Trello or a row in Google Sheets, then notify your editor in Slack.
- **Zapier** — send a Slack or email digest of the week's top outliers in your niche to the whole content team.
- **Google Sheets / Looker Studio** — keep a living dashboard of what is working in your category.
- **Slack & Discord** — post a daily "trending in our niche" alert to your creator community.
- **API & webhooks** — call it from your own app and receive results as soon as a run finishes.
- **AI agents & MCP** — feed the dataset to an LLM to auto-draft titles, hooks and scripts modelled on proven winners.

Pair it with a schedule and you have a permanent early-warning system for your niche.

***

### ❓ FAQ

**Do I need a YouTube account, API key or cookies?**
No. Nothing to connect, nothing to log in to, no quotas to manage.

**What exactly is the outlier score?**
It is the video's views divided by what that channel normally gets for that format. An outlier score of 8 means the video did eight times better than that channel's usual video. It is the fastest way to separate a genuinely great idea from a channel that is simply large.

**Why does the score stop at 500?**
Because beyond that the number stops being useful. A video that beat its channel 500 times over is already the strongest signal the dataset can give — the tier column simply calls it *viral*.

**Why is that better than sorting by views?**
Sorting by views just shows you the biggest channels. Outlier scores show you which *ideas* worked — including on small channels, which is exactly where new formats appear first.

**Does it work for Shorts?**
Yes. Set the format to *Shorts only* and short-form videos are compared only against other short-form videos, so the numbers stay honest.

**Does it work outside English?**
Yes. Choose your market in the region selector and enter your topics in any language.

**How fresh is the data?**
Every run is live at the moment you press Start. Nothing is served from a cache.

**How many videos can I get?**
Up to 5,000 scored videos per run. Add more topics to widen the pool.

**Can I track the same niche over time?**
Yes — schedule it daily or weekly. Each run is timestamped, so you can chart momentum.

**Is the revenue estimate real earnings?**
No. It is a clearly-labelled modelled range based on typical category and market rates, useful for comparison between videos, not for accounting.

**Can I use this for competitor monitoring?**
Yes. Add competitor channels instead of (or alongside) topics, and you get their entire overperformance history in one table.

***

### 🧰 More tools from the same maker

- 📝 [YouTube Transcript Turbo Saver](https://apify.com/lofomachines/youtube-transcript-turbo-saver) — pull the full transcript of any winner you find here and reverse-engineer its script and structure.
- 🎬 [TikTok Transcription AI](https://apify.com/lofomachines/tiktok-transcription-ai) — do the same across TikTok and see which hooks travel between platforms.
- 🔍 [Google Search Autocomplete: Cheaper, Faster, Reliable](https://apify.com/lofomachines/google-search-autocomplete-cheaper-faster-reliable) — turn a winning video topic into hundreds of real search queries for titles and descriptions.
- 💬 [Sentiment and Topics Text Classifier](https://apify.com/lofomachines/sentiment-and-topics-text-classifier) — classify titles, descriptions and comments at scale to map the emotional angles that convert.
- 📡 [AI Media Monitor – Brand, News & Sentiment Tracker](https://apify.com/lofomachines/ai-media-monitor) — watch how a trend spreads beyond YouTube into news and media.

***

**Keywords:** youtube viral video finder, youtube outlier finder, youtube trend tracker, youtube content ideas, youtube competitor analysis, youtube video research tool, youtube shorts research, viral video scraper, youtube analytics without api key, content strategy tool, youtube niche research, breakout video detector, youtube scraper, video idea generator, youtube seo tags.

# Actor input Schema

## `keywords` (type: `array`):

What do you want to scan? Add one topic per line, exactly how a viewer would search for it — for example `ai automation`, `high protein meal prep`, `van build`. Leave empty if you only want to analyse specific channels.

## `channels` (type: `array`):

Optional. Paste channel links or handles (one per line) to see which of their videos overperformed — perfect for competitor tracking. Accepts `@handle`, `youtube.com/@handle` or a channel URL.

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

How recent should the videos be? Shorter windows surface trends earlier; longer windows return more proven formats.

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

Shorts and long-form videos behave very differently, so each one is always compared against videos of the same format.

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

How far above its channel's normal performance a video must be before it is returned. `Overperformers` is the sweet spot for content research.

## `minViews` (type: `integer`):

Ignore videos below this view count. Raise it to skip noise, lower it to catch very early trends.

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

The country whose audience results should reflect. Trends differ a lot per market.

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

Upper limit on how many scored videos land in your dataset. Results are always returned best-first, so a smaller number simply keeps the strongest ones.

## Actor input object example

```json
{
  "keywords": [
    "ai automation"
  ],
  "channels": [
    "@MrBeast",
    "https://www.youtube.com/@veritasium"
  ],
  "publishedWithin": "30d",
  "videoFormat": "all",
  "performanceFilter": "overperformers",
  "minViews": 1000,
  "region": "US",
  "maxResults": 200
}
```

# 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 = {
    "keywords": [
        "ai automation"
    ],
    "channels": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lofomachines/youtube-viral-outlier-finder").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 = {
    "keywords": ["ai automation"],
    "channels": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lofomachines/youtube-viral-outlier-finder").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 '{
  "keywords": [
    "ai automation"
  ],
  "channels": []
}' |
apify call lofomachines/youtube-viral-outlier-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lofomachines/youtube-viral-outlier-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YouTube Viral Video Finder – Outlier & Trend Radar",
        "description": "Find the videos that massively outperform their own channel's baseline in any niche. Outlier scores, view velocity, channel context and title patterns — no account, no API key.",
        "version": "1.0",
        "x-build-id": "KHXhODlxkfn3lgAcm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lofomachines~youtube-viral-outlier-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lofomachines-youtube-viral-outlier-finder",
                "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/lofomachines~youtube-viral-outlier-finder/runs": {
            "post": {
                "operationId": "runs-sync-lofomachines-youtube-viral-outlier-finder",
                "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/lofomachines~youtube-viral-outlier-finder/run-sync": {
            "post": {
                "operationId": "run-sync-lofomachines-youtube-viral-outlier-finder",
                "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": {
                    "keywords": {
                        "title": "Topics or niches",
                        "type": "array",
                        "description": "What do you want to scan? Add one topic per line, exactly how a viewer would search for it — for example `ai automation`, `high protein meal prep`, `van build`. Leave empty if you only want to analyse specific channels.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "channels": {
                        "title": "Channels to analyse",
                        "type": "array",
                        "description": "Optional. Paste channel links or handles (one per line) to see which of their videos overperformed — perfect for competitor tracking. Accepts `@handle`, `youtube.com/@handle` or a channel URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publishedWithin": {
                        "title": "Time window",
                        "enum": [
                            "24h",
                            "7d",
                            "30d",
                            "90d",
                            "180d",
                            "365d",
                            "any"
                        ],
                        "type": "string",
                        "description": "How recent should the videos be? Shorter windows surface trends earlier; longer windows return more proven formats.",
                        "default": "30d"
                    },
                    "videoFormat": {
                        "title": "Video format",
                        "enum": [
                            "all",
                            "longform",
                            "shorts"
                        ],
                        "type": "string",
                        "description": "Shorts and long-form videos behave very differently, so each one is always compared against videos of the same format.",
                        "default": "all"
                    },
                    "performanceFilter": {
                        "title": "Performance filter",
                        "enum": [
                            "all",
                            "overperformers",
                            "breakouts",
                            "viral"
                        ],
                        "type": "string",
                        "description": "How far above its channel's normal performance a video must be before it is returned. `Overperformers` is the sweet spot for content research.",
                        "default": "overperformers"
                    },
                    "minViews": {
                        "title": "Minimum views",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Ignore videos below this view count. Raise it to skip noise, lower it to catch very early trends.",
                        "default": 1000
                    },
                    "region": {
                        "title": "Audience region",
                        "enum": [
                            "US",
                            "GB",
                            "CA",
                            "AU",
                            "IN",
                            "IE",
                            "DE",
                            "FR",
                            "IT",
                            "ES",
                            "NL",
                            "PL",
                            "SE",
                            "BR",
                            "MX",
                            "AR",
                            "PT",
                            "JP",
                            "KR",
                            "ID",
                            "PH",
                            "TR",
                            "SA",
                            "AE",
                            "ZA",
                            "NG"
                        ],
                        "type": "string",
                        "description": "The country whose audience results should reflect. Trends differ a lot per market.",
                        "default": "US"
                    },
                    "maxResults": {
                        "title": "Maximum videos to return",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Upper limit on how many scored videos land in your dataset. Results are always returned best-first, so a smaller number simply keeps the strongest ones.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
