# YouTube Channel → Blog, Newsletter & Shorts Repurposer (`yasaslive/channel-repurposer`) Actor

Watches YouTube channels for new uploads and turns every video into a ready-to-edit content bundle: SEO blog draft, newsletter section, X/LinkedIn thread, Shorts hook candidates with timestamps, and an SRT subtitle file.

- **URL**: https://apify.com/yasaslive/channel-repurposer.md
- **Developed by:** [Eonix Pvt Ltd](https://apify.com/yasaslive) (community)
- **Categories:** Automation, Social media, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Channel → Blog, Newsletter & Shorts Repurposer

**Give it a YouTube channel. Get back a ready-to-edit content bundle for every new upload — an SEO blog post, a newsletter section, an X/LinkedIn thread, Shorts hook ideas with timestamps, and a clean `.srt` subtitle file.**

Stop letting your videos die after upload. This Actor watches your channels, grabs each new video's transcript, and turns it into everything you need to promote that video across every channel you publish on — automatically.

***

### ⚡ What you get for every new video

| Output | What it is |
| --- | --- |
| 📝 **SEO blog draft** | A titled, 800–1,200 word post with meta description and H2 sections — ready to paste into your CMS |
| 📧 **Newsletter section** | A tight, punchy blurb you can drop straight into your next email |
| 🧵 **Social thread** | 6–12 posts for X or LinkedIn, each within the 280-character limit |
| 🎬 **Shorts hooks** | 3–5 scroll-stopping moments with exact timestamps to clip |
| 💬 **Key quotes** | The most quotable lines, timestamped |
| 🎞️ **SRT subtitles** | A properly formatted subtitle file for the full video |

Everything is grounded in the actual transcript — no made-up facts, no hallucinated quotes.

### 🎯 Who it's for

- **Creators & YouTubers** who want a blog post and a thread out of every video without re-watching it
- **Content & social teams** turning a video backlog into a repeatable, multi-channel pipeline
- **Newsletter writers** who need a publish-ready section per video, on a schedule
- **Agencies** repurposing client videos at scale

### 🗓️ Set it and forget it

The magic is the schedule. Attach a **6-hour schedule** to this Actor and it runs on autopilot:

1. You publish a video on YouTube.
2. A few hours later, the full repurposing bundle is waiting in your results.
3. You skim, tweak, and hit publish everywhere else.

It remembers what it has already processed, so every run only handles genuinely new uploads — no duplicates, no double charges.

### ⚙️ Inputs

| Field | Required | Description |
| --- | --- | --- |
| **YouTube channels** | ✅ | One or more channels — paste `@handles` (`@mkbhd`), full URLs, or channel IDs |
| **Max new videos per channel** | | How many new videos to process each run (default 5) |
| **Backfill count** | | How many recent videos to grab the first time (default 3) |
| **Transcript language** | | Preferred caption language, e.g. `en`, `de`, `pt-BR` (default `en`) |
| **Outputs** | | Pick any of: blog, newsletter, thread, Shorts hooks, SRT (default: all) |
| **OpenAI API key** | | Enables the AI writing. Leave empty to get transcripts + SRT only |
| **Model** | | OpenAI model for the writing (default `gpt-4o-mini`, ~$0.01/video) |
| **Proxy** | | **Use the Residential group** — YouTube blocks datacenter IPs for video/caption data |

> **💡 Turn on Residential proxy.** YouTube throttles datacenter IPs on its video and caption endpoints. With the **Residential** proxy group enabled, transcripts come through reliably. This is strongly recommended for scheduled/production use.

### 📦 Example output

One record per video (plus a run summary). Large files (SRT, blog markdown) are saved to storage and linked from the record.

```json
{
  "videoId": "aB5LGrHISqY",
  "title": "Ship Faster: 5 Habits of High-Output Engineers",
  "url": "https://www.youtube.com/watch?v=aB5LGrHISqY",
  "publishedAt": "2026-08-10T14:00:00+00:00",
  "channelTitle": "Your Channel",
  "status": "complete",
  "transcriptChars": 8396,
  "transcriptLanguage": "en",
  "captionSource": "auto",
  "bundle": {
    "blogPost": {
      "title": "5 Habits That Make Engineers Ship Faster (Without Breaking Things)",
      "metaDescription": "Speed isn't about typing quickly. Five habits that help engineers ship faster — smaller scope, tiny feedback loops, rollbacks first, automated checks, and a clear trail.",
      "markdown": "Everyone wants to ship faster, but the fastest engineers aren't the fastest typists...\n\n## Cut scope before you cut corners\n\n..."
    },
    "newsletterSection": "**Ship faster, break less.** This week: five habits of high-output engineers...",
    "thread": [
      "The fastest engineers I know aren't the fastest typists. They're ruthless about shrinking the work. 5 habits to ship faster without breaking things 🧵",
      "1. Cut scope before you cut corners. Half a feature that ships beats a whole one that stalls.",
      "..."
    ],
    "shortsHooks": [
      { "startTimestamp": "00:00:00", "hookText": "Speed isn't about typing quickly.", "why": "Counter-intuitive opener that challenges the viewer in the first second." }
    ],
    "keyQuotes": [
      { "timestamp": "00:00:26", "quote": "Write the rollback before the rollout." }
    ]
  },
  "srtUrl": "https://api.apify.com/v2/key-value-stores/.../records/aB5LGrHISqY.srt",
  "blogUrl": "https://api.apify.com/v2/key-value-stores/.../records/aB5LGrHISqY-blog.md"
}
```

And the linked `.srt` file:

```srt
1
00:00:00,000 --> 00:00:03,560
On Monday, the company that spent the

2
00:00:01,680 --> 00:00:05,640
last year building its new model
```

### 💵 Pricing (Pay-Per-Event)

You're charged **only for work that succeeds** — never for a video with no captions, a restricted video, or a failed run.

| Event | Price | When |
| --- | --- | --- |
| **Video transcribed** | $0.03 | Per video with a successfully extracted transcript + SRT |
| **AI bundle** | $0.10 | Per video where the blog/newsletter/thread/Shorts bundle is generated |

A creator processing ~20 videos a month with full bundles pays about **$2.60/month**. No new uploads that run? You pay nothing.

> The AI writing uses **your own** OpenAI API key, so those model costs (~$0.01/video) are billed to you directly by OpenAI — this Actor never marks them up.

### 💡 Use cases

1. **Newsletter on autopilot** — schedule it on your channel; each week, paste the newest newsletter section into your email tool.
2. **Repurpose your back catalogue** — set backfill to 15 and run once to turn your last 15 videos into blog drafts and threads in a single pass.
3. **Shorts factory** — choose only "Shorts hooks" + "SRT" to get timestamped clip candidates, subtitles included, for every long-form video.

### ❓ FAQ

**Do I need an OpenAI key?** No. Without one you still get transcripts and SRT files (and only pay the transcription event). Add a key to unlock the blog, newsletter, thread, and Shorts hooks.

**What counts as a "new" video?** Anything the Actor hasn't processed before. It keeps track between runs, so it never reprocesses or double-charges — and the first run backfills your most recent videos.

**What if a video has no captions?** It's recorded as `no_transcript` and **you're not charged**. Age-restricted or members-only videos are skipped (also free). Live streams and premieres are retried on a later run.

**Which languages work?** Any language YouTube has captions for. Set your preferred language code and the Actor picks the best available track.

**Is my OpenAI key safe?** Yes — it's a secret input, encrypted at rest, never logged, and never included in the output.

**Why do I need a residential proxy?** YouTube limits datacenter IPs on its player and caption endpoints. The Residential group avoids the "video unavailable" / empty-transcript problem.

### 🚀 Get started

1. Paste one or more channels into **YouTube channels**.
2. (Optional) Add your **OpenAI API key** for the full AI bundle.
3. Turn on **Residential** proxy.
4. Run it — or attach a **6-hour schedule** and let new uploads flow in as ready-to-edit content.

***

#### Changelog

**0.1** — Initial release: channel watching, new-upload detection, transcript + SRT extraction, and one-call AI repurposing (blog, newsletter, thread, Shorts hooks, key quotes).

# Actor input Schema

## `channelUrls` (type: `array`):

Channels to watch. Accepts @handles (`@mkbhd`), full channel URLs (`https://www.youtube.com/@mkbhd`, `https://www.youtube.com/channel/UC...`), or bare channel IDs (`UC...`).

## `maxNewVideosPerChannel` (type: `integer`):

Upper bound on how many unseen videos are processed per channel in one run (the RSS feed exposes at most 15). Videos over the cap stay unseen and are picked up by the next run.

## `backfillCount` (type: `integer`):

How many of the most recent videos to process the very first time a channel is seen. Set 0 to only process uploads that appear after the first run.

## `language` (type: `string`):

BCP-47 language code (e.g. `en`, `en-US`, `de`, `pt-BR`). Manual captions in this language are preferred, then auto-generated ones, then any available track.

## `outputs` (type: `array`):

Which parts of the repurposing bundle to produce. `blog`, `newsletter`, `thread` and `shortsHooks` require an OpenAI API key; `srt` is generated straight from the captions.

## `openaiApiKey` (type: `string`):

Used for the AI repurposing bundle (one structured call per video). If omitted, the actor still produces transcripts and SRT files — you are only charged the transcription event.

## `model` (type: `string`):

Chat Completions model used for the bundle. `gpt-4o-mini` keeps the cost around $0.01 per video.

## `proxyConfiguration` (type: `object`):

Proxy for YouTube requests. YouTube blocks some datacenter IPs, so Apify Proxy with the RESIDENTIAL group is recommended for reliable transcripts at scale.

## Actor input object example

```json
{
  "channelUrls": [
    "https://www.youtube.com/@Fireship"
  ],
  "maxNewVideosPerChannel": 5,
  "backfillCount": 3,
  "language": "en",
  "outputs": [
    "blog",
    "newsletter",
    "thread",
    "shortsHooks",
    "srt"
  ],
  "model": "gpt-4o-mini",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `videos` (type: `string`):

One record per video: metadata, status, transcript stats, the AI bundle, and links to the generated files.

## `files` (type: `string`):

The {videoId}.srt subtitle files and {videoId}-blog.md drafts in the default key-value store.

# 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 = {
    "channelUrls": [
        "https://www.youtube.com/@Fireship"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yasaslive/channel-repurposer").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 = {
    "channelUrls": ["https://www.youtube.com/@Fireship"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("yasaslive/channel-repurposer").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 '{
  "channelUrls": [
    "https://www.youtube.com/@Fireship"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call yasaslive/channel-repurposer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yasaslive/channel-repurposer"
        }
    }
}

```

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/So9E4jcps5BNIrVsD/builds/faW3ohVnLPbodBShd/openapi.json