# YouTube AI Classifier (Videos & Channels) (`trysmartapi/youtube-ai-classifier`) Actor Classify YouTube videos and channels with AI: category, language, sentiment, keywords, and audience — from a search query or a list of URLs. - **URL**: https://apify.com/trysmartapi/youtube-ai-classifier.md - **Developed by:** [Smart API](https://apify.com/trysmartapi) (community) - **Categories:** AI - **Stats:** 8 total users, 6 monthly users, 100.0% runs succeeded, 1 bookmarks - **User rating**: 5.00 out of 5 stars ## Pricing $0.75 / 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. 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/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 AI Classifier (Videos & Channels) Classify any YouTube **video or channel** with AI — get structured insights in seconds: **category & sub-category, language, sentiment, keywords, and full audience demographics (age distribution + gender split)** — plus live stats, in one clean dataset. Feed it a **search query** ("crypto podcast", "yoga for beginners") or a **list of video/channel URLs, @handles, usernames, or IDs** (mixed freely) and get one classified row per item. No YouTube API key needed, no quota headaches. ### How to use (30 seconds) 1. **Enter a search query** or paste video/channel URLs into the input form 2. Optionally enable **channel audit mode** to also classify each channel's latest or most popular videos 3. Click **Start** — results appear in the dataset, exportable as JSON, CSV, or Excel, or pull them via API ### Example output (real run) ```json { "type": "video", "id": "dQw4w9WgXcQ", "url": "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "title": "Rick Astley - Never Gonna Give You Up (Official Video) (4K Remaster)", "channelTitle": "Rick Astley", "publishedAt": "2009-10-25T06:57:33Z", "viewCount": "1793028296", "likeCount": "19245436", "commentCount": "2444774", "category": "Music", "subCategory": "80s pop music", "language": "English", "languageCode": "en", "sentiment": "positive", "keywords": ["rick astley", "never gonna give you up", "80s music", "pop music", "rickroll", "meme"], "audiencePrimaryAge": "18-24", "audienceAgeDistribution": { "13-17": 15, "18-24": 25, "25-34": 20, "35-44": 15, "45-54": 15, "55+": 10 }, "audiencePrimaryGender": "male", "audienceGenderSplit": { "male": 52, "female": 48 } } ```` ### What you get per item | Field | Description | |---|---| | `type` | `video` or `channel` | | `id`, `url`, `title` | Identity of the classified item | | `category` / `subCategory` | AI-assigned content category from a fixed taxonomy | | `language` / `languageCode` | Detected primary language (name + ISO code) | | `sentiment` | Overall sentiment of the content | | `keywords` | Key topics extracted by AI | | `audiencePrimaryAge` / `audienceAgeDistribution` | Dominant age group + full age breakdown (13-17 … 55+) | | `audiencePrimaryGender` / `audienceGenderSplit` | Dominant gender + percentage split | | `viewCount`, `likeCount`, `commentCount`, `duration`, `tags` | Live video stats (videos) | | `subscriberCount`, `videoCount`, `country`, `customUrl` | Live channel stats (channels) | | `sourceChannelId` | On videos found via channel audit mode — groups results by channel | Live stats are fetched fresh on every run — even when a classification is served from cache, the numbers are current. ### Use cases - **Influencer discovery & vetting** — classify a list of channels before outreach: right topic, right language, right audience demographics? - **Brand safety** — check sentiment and category of channels/videos before placing sponsorships - **Channel audits** — one input, full picture: the channel plus its latest or most popular videos, all classified - **Content research** — search a niche and see how the landscape is categorized, what keywords dominate, who it targets - **Dataset labeling** — enrich video lists with structured labels for analytics or ML pipelines ### Input examples Search and classify: ```json { "searchQuery": "personal finance india", "maxResults": 25 } ``` Classify specific items (URLs, @handles, usernames, ids — mixed): ```json { "targets": [ "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "mkbhd", "UCu59yAFE8fM0sVNTipR4edw" ] } ``` **Full channel audit** — classify a channel AND its videos (latest or most popular) in one run: ```json { "targets": ["@mkbhd"], "classifyChannelVideos": true, "videosOrder": "popular", "videosPerChannel": 10, "maxResults": 11 } ``` > Tip: bare usernames are resolved via channel search, which can be ambiguous — > use the exact `@handle` or the `UC…` channel ID when precision matters. ### Developer / API guide This actor is a standard Apify Actor, so it doubles as a hosted API. You only need **your own Apify API token** — no YouTube API key, no backend setup. - **Actor ID:** `trysmartapi~youtube-ai-classifier` - **Base URL:** `https://api.apify.com/v2` - **Auth:** append `?token=` to any URL, **or** send the header `Authorization: Bearer ` - **Get your token:** [Apify Console → Settings → API & Integrations](https://console.apify.com/settings/integrations) > Replace `` everywhere below with your real token. Keep it secret — > treat it like a password (prefer the `Authorization` header or an env var over > putting it in URLs that get logged). #### The one call you need — run and get results (synchronous) `run-sync-get-dataset-items` starts a run, waits for it to finish, and returns the classified rows as a JSON array in the response body. Best for small/medium runs (it holds the connection open up to ~5 minutes). ``` POST https://api.apify.com/v2/acts/trysmartapi~youtube-ai-classifier/run-sync-get-dataset-items?token= Content-Type: application/json ← the same fields you'd fill in the input form ``` ##### curl ```bash curl -X POST \ "https://api.apify.com/v2/acts/trysmartapi~youtube-ai-classifier/run-sync-get-dataset-items?token=" \ -H "Content-Type: application/json" \ -d '{ "searchQuery": "personal finance india", "maxResults": 10 }' ``` Classify a specific mixed list (video URL, @handle, channel ID): ```bash curl -X POST \ "https://api.apify.com/v2/acts/trysmartapi~youtube-ai-classifier/run-sync-get-dataset-items?token=" \ -H "Content-Type: application/json" \ -d '{ "targets": [ "https://www.youtube.com/watch?v=dQw4w9WgXcQ", "@mkbhd", "UCu59yAFE8fM0sVNTipR4edw" ] }' ``` The response is a JSON array — one object per classified item (see [What you get per item](#what-you-get-per-item) and the example above). ##### Python — plain `requests` (no SDK) ```python import os import requests APIFY_TOKEN = os.environ["APIFY_TOKEN"] ACTOR = "trysmartapi~youtube-ai-classifier" resp = requests.post( f"https://api.apify.com/v2/acts/{ACTOR}/run-sync-get-dataset-items", params={"token": APIFY_TOKEN}, json={ "searchQuery": "personal finance india", "maxResults": 10, }, timeout=310, ) resp.raise_for_status() items = resp.json() # list[dict] — one classified row per item for item in items: print(item["type"], "|", item.get("title"), "->", item["category"], "/", item["subCategory"], "|", item["sentiment"], "|", item["language"]) ``` ##### Python — official `apify-client` SDK ```bash pip install apify-client ``` ```python import os from apify_client import ApifyClient client = ApifyClient(os.environ["APIFY_TOKEN"]) run = client.actor("trysmartapi~youtube-ai-classifier").call( run_input={ "targets": ["@mkbhd"], "classifyChannelVideos": True, "videosOrder": "popular", "videosPerChannel": 10, "maxResults": 11, } ) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["type"], item.get("title"), "->", item["category"]) ``` #### Large runs — start async, then fetch (non-blocking) For big batches, start the run without waiting, poll its status, then read the dataset. This avoids the ~5-minute sync limit. ```bash ## 1. Start the run — returns immediately with a run id + defaultDatasetId curl -s -X POST \ "https://api.apify.com/v2/acts/trysmartapi~youtube-ai-classifier/runs?token=" \ -H "Content-Type: application/json" \ -d '{ "searchQuery": "gaming", "maxResults": 100 }' ## 2. Poll status (repeat until "status": "SUCCEEDED") curl -s "https://api.apify.com/v2/actor-runs/?token=" ## 3. Fetch the classified rows curl -s "https://api.apify.com/v2/datasets//items?token=" ``` Add `&format=csv` (or `xlsx`, `xml`) to the dataset URL to download other formats instead of JSON. #### Input parameters Send any of these in the JSON body. All are optional, but provide **either** `searchQuery` **or** `targets` (you can use both). | Field | Type | Default | Description | |---|---|---|---| | `searchQuery` | string | — | Find videos by YouTube search and classify them | | `targets` | string\[] | — | Video/channel URLs, channel IDs, `@handles`, or usernames — mixed freely | | `maxResults` | integer (1–100) | `5` | Max items to classify. You're only charged for successful classifications | | `classifyChannelVideos` | boolean | `false` | For each channel target, also classify its videos (full channel audit) | | `videosOrder` | `"latest"` | `"popular"` | `"latest"` | Which videos to pull per channel (only with `classifyChannelVideos`) | | `videosPerChannel` | integer (3–50) | `5` | Videos to classify per channel (only with `classifyChannelVideos`) | | `includeInfo` | boolean | `true` | Include live details (title, stats, publish date). Always fetched fresh | | `regionCode` | string | — | ISO 3166-1 alpha-2 country code for search (e.g. `US`, `IN`, `GB`) | #### Give this to Claude / a coding agent Paste the block below into Claude, Cursor, or any coding agent to have it wire up the integration for you — it only needs your Apify token as `APIFY_TOKEN`. ```text Integrate the "YouTube AI Classifier" Apify Actor into my project. It classifies YouTube videos and channels with AI (category, sub-category, language, sentiment, keywords, and audience age/gender demographics) plus live stats. Auth is my Apify API token only — no YouTube API key needed. - Actor ID: trysmartapi~youtube-ai-classifier - Auth: read the token from the APIFY_TOKEN environment variable. Never hardcode it. - Simple (small runs) — one HTTP call returns results as a JSON array: POST https://api.apify.com/v2/acts/trysmartapi~youtube-ai-classifier/run-sync-get-dataset-items?token=$APIFY_TOKEN Content-Type: application/json Body (JSON input, all optional — send searchQuery OR targets): { "searchQuery": "", // find + classify videos "targets": ["", ...], "maxResults": 10, // 1..100, default 5 "classifyChannelVideos": false, // audit a channel's videos too "videosOrder": "latest", // or "popular" "videosPerChannel": 5, // 3..50 "includeInfo": true, // include live stats "regionCode": "US" } // optional ISO country code - Large runs: POST .../acts/trysmartapi~youtube-ai-classifier/runs to start async, poll GET .../actor-runs/ until status == "SUCCEEDED", then GET .../datasets//items for the rows. Each result row has: type ("video"|"channel"), id, url, title, category, subCategory, language, languageCode, sentiment, keywords[], audiencePrimaryAge, audienceAgeDistribution{}, audiencePrimaryGender, audienceGenderSplit{}, plus live stats (viewCount/likeCount/commentCount for videos; subscriberCount/videoCount/country for channels). Write a small, reusable client function for my stack (ask me which language if unclear), read APIFY_TOKEN from the environment, handle HTTP errors, and show a usage example that classifies a search query and prints category + sentiment per item. ``` ### Pricing Pay per result — you're only charged for successfully classified items. Failed lookups cost nothing. The default run classifies just 5 items, so trying it out costs next to nothing; raise **Max items** when you're ready to scale. ### Need raw API access? This actor is powered by our YouTube data platform. If you'd rather integrate directly in your own code (search, channels, videos, full comment threads with replies, and AI classification), get an API key on RapidAPI: **YouTube AI Classification & Data API** — v3-compatible JSON, no daily quota. *** *Questions or a field you need added? Open an issue on this actor — feature requests ship fast.* # Actor input Schema ## `searchQuery` (type: `string`): Find videos by YouTube search and classify them. Leave empty if providing URLs below. ## `targets` (type: `array`): YouTube video URLs, channel URLs, channel IDs, @handles, or plain usernames — mixed freely. ## `maxResults` (type: `integer`): Maximum number of videos/channels to classify in this run. You are only charged for successfully classified items. ## `classifyChannelVideos` (type: `boolean`): For every channel in the input, also fetch and classify its most recent videos — a full channel audit in one run. ## `videosOrder` (type: `string`): Pick the channel's latest uploads or its most popular videos. ## `videosPerChannel` (type: `integer`): How many videos to classify per channel (3-50, only used when the option above is enabled). The overall 'Max items' cap still applies. ## `includeInfo` (type: `boolean`): Add live details to each result: title, description, publish date, and current statistics (views, likes, subscribers). Always fetched fresh, even when the classification is cached. ## `regionCode` (type: `string`): Optional ISO 3166-1 alpha-2 country code for search (e.g. US, IN, GB). ## Actor input object example ```json { "searchQuery": "machine learning tutorial", "maxResults": 5, "classifyChannelVideos": false, "videosOrder": "latest", "videosPerChannel": 5, "includeInfo": true } ``` # Actor output Schema ## `classifiedItems` (type: `string`): One row per classified video or channel: category, sub-category, language, sentiment, keywords, and audience demographics, plus live stats. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "searchQuery": "machine learning tutorial" }; // Run the Actor and wait for it to finish const run = await client.actor("trysmartapi/youtube-ai-classifier").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "searchQuery": "machine learning tutorial" } # Run the Actor and wait for it to finish run = client.actor("trysmartapi/youtube-ai-classifier").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 '{ "searchQuery": "machine learning tutorial" }' | apify call trysmartapi/youtube-ai-classifier --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=trysmartapi/youtube-ai-classifier", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "YouTube AI Classifier (Videos & Channels)", "description": "Classify YouTube videos and channels with AI: category, language, sentiment, keywords, and audience — from a search query or a list of URLs.", "version": "0.1", "x-build-id": "ynPtUoIYOYpLfxeVe" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/trysmartapi~youtube-ai-classifier/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-trysmartapi-youtube-ai-classifier", "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/trysmartapi~youtube-ai-classifier/runs": { "post": { "operationId": "runs-sync-trysmartapi-youtube-ai-classifier", "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/trysmartapi~youtube-ai-classifier/run-sync": { "post": { "operationId": "run-sync-trysmartapi-youtube-ai-classifier", "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": { "searchQuery": { "title": "Search query", "type": "string", "description": "Find videos by YouTube search and classify them. Leave empty if providing URLs below." }, "targets": { "title": "Video or channel URLs", "type": "array", "description": "YouTube video URLs, channel URLs, channel IDs, @handles, or plain usernames — mixed freely.", "items": { "type": "string" } }, "maxResults": { "title": "Max items to classify", "minimum": 1, "maximum": 100, "type": "integer", "description": "Maximum number of videos/channels to classify in this run. You are only charged for successfully classified items.", "default": 5 }, "classifyChannelVideos": { "title": "Also classify each channel's videos", "type": "boolean", "description": "For every channel in the input, also fetch and classify its most recent videos — a full channel audit in one run.", "default": false }, "videosOrder": { "title": "Which videos per channel", "enum": [ "latest", "popular" ], "type": "string", "description": "Pick the channel's latest uploads or its most popular videos.", "default": "latest" }, "videosPerChannel": { "title": "Videos per channel", "minimum": 3, "maximum": 50, "type": "integer", "description": "How many videos to classify per channel (3-50, only used when the option above is enabled). The overall 'Max items' cap still applies.", "default": 5 }, "includeInfo": { "title": "Include video/channel details", "type": "boolean", "description": "Add live details to each result: title, description, publish date, and current statistics (views, likes, subscribers). Always fetched fresh, even when the classification is cached.", "default": true }, "regionCode": { "title": "Region code", "type": "string", "description": "Optional ISO 3166-1 alpha-2 country code for search (e.g. US, IN, GB)." } } }, "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 } } } } } } } } } } ```