# YouTube Audience Brief - Transcripts To Content Strategy (`sprightly_blackberry/youtube-audience-brief`) Actor

Turn YouTube transcripts into a content strategy: proven hooks, audience questions, packaging gaps, and next-video ideas. Pay per report.

- **URL**: https://apify.com/sprightly\_blackberry/youtube-audience-brief.md
- **Developed by:** [ming zou](https://apify.com/sprightly_blackberry) (community)
- **Categories:** AI, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $900.00 / 1,000 reports

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## YouTube Audience Brief - Transcripts To Content Strategy

Turn YouTube transcripts into a content strategy: proven hooks, audience questions, packaging gaps, and next-video ideas. Pay per report.

### What this Actor does

It collects public source data (see *Evidence sources*), then uses a language model to turn that raw material into one structured report. One run produces one report, and you pay only when a report is delivered.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `queries` | array | yes | Search queries |
| `maxRecords` | integer | no | Videos to analyze |
| `subtitle_language` | string | no | Subtitle language |
| `date_filter` | string | no | Publish window |
| `outputLanguage` | string | no | Report language |
| `sampleData` | boolean | no | Sample data (free, no data fetched) |

#### Advanced

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `llmApiKey` | string | no | Optional. Leave empty to use the service's built-in analysis model. Supply your own OpenAI-compatible key to bill model usage to your account. Stored encrypted. |
| `llmApiBase` | string | no | OpenAI-compatible base URL. Empty means the service default. |
| `llmModel` | string | no | Model identifier. Empty means the service default. |

### Output

One dataset item per run. Report fields:

| Field | Type | Description |
| --- | --- | --- |
| `provenHooks` | array | Proven hooks |
| `audienceQuestions` | array | Audience questions |
| `repeatedClaims` | array | Repeated claims |
| `contentGaps` | array | Content gaps |
| `packagingIdeas` | array | Packaging ideas |
| `seriesPlan` | array | Series plan |

Every report also carries:

| Field | Type | Description |
| --- | --- | --- |
| `scope` | object | Inputs and filters this report was produced for. |
| `sourceRecordCount` | integer | Records collected from the source. |
| `recordsAnalyzed` | integer | Records actually included in the analysis. |
| `recordsDroppedPastBudget` | integer | Records excluded once the analysis budget was reached. |
| `chunksAnalyzed` | integer | Number of analysis passes merged into the report. |
| `sources` | array | Upstream dataset identifiers used as evidence. |
| `limitations` | array | Known limits of this analysis. |
| `demoMode` | boolean | `true` when no model key was configured. |
| `generatedAt` | string | ISO-8601 timestamp. |

### Evidence source

Upstream Actor: `streamers~youtube-scraper` (YouTube videos and transcripts). Data is collected at run time from publicly visible pages.

### Pricing

Pay per event: **$0.90** per delivered report (`strategy-report`). For comparison, vidIQ and TubeBuddy charge roughly $20-$50/mo for research features alone.

### Example input

```json
{
  "queries": [
    "AI coding assistant workflow"
  ],
  "subtitle_language": "en",
  "sampleData": true
}
```

### Demo mode

If no model key is configured, the Actor still runs end to end and returns an extractive evidence report (record counts, frequency-ranked terms, verbatim samples) instead of model synthesis, with `demoMode: true`. This lets you evaluate a run before connecting a model.

### Limitations

- Analysis is derived solely from publicly visible data collected at run time; it reflects the sampled window, not the full population.
- Results reflect the material collected in this run, not the entire population of available data.
- Analysis quality depends on how much public text the source exposes.

Independent third-party analysis service. Not affiliated with, endorsed by, or sponsored by the platforms whose public data is analyzed.

# Actor input Schema

## `queries` (type: `array`):

Topics or channels to analyze.

## `maxRecords` (type: `integer`):

How many videos to pull and read.

## `subtitle_language` (type: `string`):

Subtitle language code.

## `date_filter` (type: `string`):

How recent the videos must be.

## `outputLanguage` (type: `string`):

Language used for the generated report.

## `sampleData` (type: `boolean`):

ON by default so the first run is instant and free. Returns a sample report that shows the exact output shape without calling any paid data source. Turn it OFF and fill in your own target to run the real analysis.

## `llmApiKey` (type: `string`):

Optional. Leave empty to use the service's built-in analysis model. Supply an OpenAI-compatible API key to run the analysis against your own account.

## `llmApiBase` (type: `string`):

OpenAI-compatible base URL. Leave empty to use the service default.

## `llmModel` (type: `string`):

Model identifier to send to the endpoint above.

## Actor input object example

```json
{
  "queries": [
    "AI coding assistant workflow"
  ],
  "maxRecords": 12,
  "subtitle_language": "en",
  "date_filter": "year",
  "outputLanguage": "English",
  "sampleData": true,
  "llmApiBase": "",
  "llmModel": ""
}
```

# Actor output Schema

## `report` (type: `string`):

One structured report per run.

# 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 = {
    "queries": [
        "AI coding assistant workflow"
    ],
    "subtitle_language": "en",
    "sampleData": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("sprightly_blackberry/youtube-audience-brief").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 = {
    "queries": ["AI coding assistant workflow"],
    "subtitle_language": "en",
    "sampleData": True,
}

# Run the Actor and wait for it to finish
run = client.actor("sprightly_blackberry/youtube-audience-brief").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "AI coding assistant workflow"
  ],
  "subtitle_language": "en",
  "sampleData": true
}' |
apify call sprightly_blackberry/youtube-audience-brief --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sprightly_blackberry/youtube-audience-brief"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Way3w40Ud54x5AXuv/builds/kazaxeoPSbehiXQaE/openapi.json