Launch a Faceless YouTube Shorts Channel

Build a free AI pipeline that auto-generates and uploads YouTube Shorts daily.

Introduction

30 Second Summary

YouTube Shorts creators are earning real money from faceless channels that never show a person on camera. These channels post daily educational or motivational clips assembled entirely by software.

In this project, you will build a fully automated video pipeline on your Windows PC that writes scripts with AI, generates voiceovers, downloads stock footage, adds captions, and assembles publish-ready YouTube Shorts from a single command.

What You'll Build

A local, zero-cost video production pipeline using Python, FFmpeg, and free AI APIs that generates faceless YouTube Shorts automatically.

By the end of this project, you'll have:

  • A configured FreeFaceless pipeline cloned and running on your machine, with free API keys for Groq (AI scripts) and Pexels (stock video) set up and working.
  • Your first AI-generated YouTube Short (script, neural voiceover, stock footage, karaoke captions) saved as a 1080x1920 MP4 ready for upload.
  • YouTube Data API v3 credentials configured so your pipeline can auto-upload Shorts directly to your channel.
  • Secret Mission: Set up automated daily posting with Windows Task Scheduler so your channel publishes a new Short every day without you lifting a finger.

Are there any prerequisites?

You need a Google account with a YouTube channel already created. If you don't have one yet, head to youtube.com and click Create a channel before starting this project.

Before We Start

Before We Start...

Install Python, FFmpeg, and Git

Your automated YouTube Shorts pipeline runs on three core tools that need to be installed on your Windows machine.

Python runs the automation scripts. FFmpeg handles video assembly and encoding. Git lets you download the pipeline code from GitHub.

In this step, get ready to:
  • Install Python 3.11+ and add it to your system PATH.
  • Install FFmpeg for video processing.
  • Install Git for cloning repositories.
Install Python 3.11+

Python is the language the FreeFaceless pipeline is written in. You need version 3.11 or higher for it to work correctly.

  • Open your browser and go to python.org/downloads.
  • Click the large yellow **Download Python** button at the top of the page.
  • Once the installer downloads, double-click it to launch it.
  • On the very first screen of the installer, check the box labelled Add Python to PATH at the bottom. This is critical.
  • Click Install Now and wait for the installation to complete.
  • Click Close when the installer finishes.

Why is Add Python to PATH so important?

PATH is a list of folders Windows searches when you type a command. Without this checkbox, Windows won't know where to find python when you type it in PowerShell.

Now verify the installation by opening PowerShell.

  • Press the Windows key to open your search bar.
  • Type PowerShell and press Enter to open it.
  • Check your Python version by running this command:
python --version

✔️ I see version 3.11 or higher

You should see something like Python 3.11.x or Python 3.12.x. Python is ready to go.

ⓧ I see a version lower than 3.11

You have an older Python installed that won't work with this project. You need to install 3.11 or higher alongside it.

  • Go back to python.org/downloads and download the latest Python 3.11+ installer.
  • Run the installer. Make sure Add Python to PATH is checked.
  • Close and reopen PowerShell, then run python --version again.
  • If Windows still shows the old version, try running python3 --version instead.

Still seeing the old version?

Windows may be finding the old Python first. Open the Start menu, search for Manage app execution aliases, and turn off the aliases for python.exe and python3.exe. Then close and reopen PowerShell.

Why is my Python version still showing the old one?

ⓧ Command not found

This means Python didn't get added to your PATH during installation.

  • Re-run the Python installer you just downloaded.
  • Select Modify.
  • Click Next on the Optional Features screen.
  • On the Advanced Options screen, check Add Python to environment variables.
  • Click Install.
  • Close PowerShell completely and reopen it, then run python --version again.

Still not working after re-running the installer?

Help me troubleshoot Python not being recognized in PowerShell.

Install FFmpeg

FFmpeg is the tool that combines your stock footage, voiceover, and captions into a finished video file.

  • Open your browser and go to https://www.gyan.dev/ffmpeg/builds/.
  • Under the release builds section, download the essentials build (the .zip file).
  • Extract the downloaded zip file.
  • Rename the extracted folder to ffmpeg and move it to C:\ so the final path is C:\ffmpeg.

What is FFmpeg?

FFmpeg is a free, open-source command-line tool for processing video and audio. It can trim, merge, encode, and add subtitles to media files. The pipeline uses it behind the scenes to assemble your final Short.

Now you need to add FFmpeg to your system PATH so Windows can find it from any terminal window.

  • Press the Windows key to open your search bar.
  • Type Edit the system environment variables and press Enter.
  • In the System Properties window, click Environment Variables at the bottom.
  • In the System variables section (bottom half), find and select the row called Path.
  • Click Edit.
  • Click New and type C:\ffmpeg\bin.
  • Click OK on all three open dialogs to save.

Why add the bin folder specifically?

The ffmpeg.exe file lives inside the bin subfolder. Adding C:\ffmpeg\bin to PATH tells Windows exactly where to find the executable.

You must restart PowerShell for the PATH change to take effect.

  • Close your current PowerShell window completely.
  • Open a new PowerShell window (press the Windows key, type PowerShell, press Enter).
  • Verify FFmpeg by running this command:
ffmpeg -version

✔️ I see a version number

You should see output starting with ffmpeg version followed by a version string and build details. FFmpeg is ready.

ⓧ Command not found

This means the PATH entry wasn't saved correctly, or you didn't restart PowerShell.

  • Make sure you fully closed the old PowerShell window before opening a new one.
  • Double-check that the folder C:\ffmpeg\bin actually exists and contains ffmpeg.exe. Open File Explorer and navigate there to confirm.
  • If the folder is in a different location, go back to the Environment Variables editor and update the Path entry to match where you actually extracted FFmpeg.

Still not recognized after restarting PowerShell?

Help me fix FFmpeg not being found in PowerShell on Windows.

Install Git

Git is the version control tool you'll use to download the FreeFaceless pipeline code from GitHub.

  • Open your browser and go to https://git-scm.com/downloads/win.
  • Download the standalone installer for Windows (the 64-bit version).
  • Run the installer. Accept all the default settings by clicking Next on each screen.
  • Click Install, then Finish when complete.

Why accept all the defaults?

The Git installer asks many questions about line endings, terminal emulator, and credential helpers. The defaults are correct for this project and will add git to your PATH automatically.

  • Close your current PowerShell window and open a fresh one (press the Windows key, type PowerShell, press Enter).
  • Verify Git by running this command:
git --version

✔️ I see a version number

You should see something like git version 2.x.x.windows.x. Git is ready.

ⓧ Command not found

This usually means you need to restart PowerShell, or the installer didn't complete.

  • Make sure you fully closed and reopened PowerShell after installing Git.
  • If that doesn't work, re-run the Git installer and make sure you don't uncheck any PATH-related options during setup.

Git still not recognized?

Help me fix Git not being found in PowerShell after installation.

All three tools are installed and verified. Next up, you'll grab your free API keys for AI script generation and stock video footage.

Get Your Free API Keys

Your video pipeline needs three external services to work. It uses an AI model to write scripts, a stock video library to source footage, and the YouTube platform to upload the finished Short.

Each service requires an API key to verify your identity when the pipeline sends requests. In this step, you will create free accounts on all three platforms and collect the credentials your pipeline needs.

In this step, get ready to:
  • Get a Groq API key for AI script generation.
  • Get a Pexels API key for stock video footage.
  • Set up YouTube Data API v3 credentials for auto-upload.
Get a Groq API key

Groq provides free access to powerful language models like Llama 3.3 70B. The pipeline uses Groq to generate unique video scripts for each Short.

  • Open your browser and go to https://console.groq.com.
  • Click Sign Up and create a free account. No credit card is required.
  • Once logged in, navigate to API Keys in the left sidebar.
  • Click Create API Key.
  • Give your key a name (e.g. yt-shorts) and click Submit.
  • Copy your new API key and paste it into a temporary text file on your Desktop. You will need it in the next step.

What is an API key?

An API key is a unique string that identifies your account when software makes requests to an external service. It works like a password for machine-to-machine communication.

Keep your keys private. Anyone with your key can make requests on your behalf and consume your free-tier quota.

Can't find the API Keys page?

Make sure you are on console.groq.com (not groq.com). After logging in, look for API Keys in the left navigation panel.

help me find where to create an API key on Groq's console

Get a Pexels API key

Pexels is a free stock photo and video library. The pipeline downloads relevant video clips from Pexels to use as B-roll footage behind your voiceover.

  • Go to https://www.pexels.com/api/.
  • Click Your API Key to start the signup process.
  • Create a free Pexels account (or sign in with Google).
  • After signing in, you will receive your API key instantly on the page.
  • Copy the key and paste it into the same temporary text file where you saved your Groq key.

How much can I use for free?

The Pexels API includes 200 requests per hour and 20,000 requests per month on the free tier. Generating one video uses only a handful of requests, so this limit is more than enough for daily video production.

Set up YouTube Data API v3 credentials

The YouTube Data API v3 lets the pipeline upload your finished Short directly to your channel. This setup requires creating a project in Google Cloud Console and generating OAuth 2.0 credentials.

OAuth 2.0 is an authorization standard that lets the pipeline act on your behalf (uploading videos) without ever storing your Google password.

  • Go to https://console.cloud.google.com and sign in with your Google account.
  • At the top of the page, click the project dropdown (it may say Select a project).
  • Click New Project.
  • Enter YT-Shorts-Bot as the project name, then click Create.
  • Wait a few seconds for the project to be created, then select it from the project dropdown.

Now enable the YouTube Data API v3 for your new project.

  • In the left navigation menu, click APIs & Services, then Library.
  • Search for YouTube Data API v3 in the search bar.
  • Click the result, then click Enable.

Next, create OAuth 2.0 credentials so the pipeline can upload on your behalf.

  • In the left menu, click APIs & Services, then Credentials.
  • Click + Create Credentials at the top, then select OAuth client ID.

What if I'm asked to configure a consent screen?

If this is your first OAuth client in this project, Google will prompt you to configure the OAuth consent screen before proceeding. Follow these steps:

  • Choose External and click Create.
  • Fill in the App name field (e.g. YT-Shorts-Bot) and your email address in the required fields.
  • Click Save and Continue through each remaining page (Scopes, Test users, Summary) without changing anything.
  • Return to Credentials in the left menu and click + Create Credentials again.
  • In the Application type dropdown, select Desktop app.
  • Leave the default name or type YT-Shorts-Bot.
  • Click Create.
  • A dialog appears showing your new credentials. Click Download JSON to save the file to your computer.
  • Rename the downloaded file to client_secrets.json and keep it in your Downloads folder for now. You will move it into the project folder in the next step.

Don't see the Download JSON button?

If you closed the dialog, go back to APIs & Services then Credentials. Under OAuth 2.0 Client IDs, click the download icon next to your client to get the JSON file.

help me download my OAuth client JSON from Google Cloud Console

All three credentials are ready. Next up, you will clone the video pipeline, wire in these keys, and customize the configuration for your chosen niche.

Clone and Configure the Pipeline

You now have all three sets of credentials saved and ready to go. The next step is to bring the automation pipeline itself onto your machine and wire everything together.

FreeFaceless is an open-source Python project that handles the entire video creation process from script to upload. You will clone it from GitHub, connect your API keys, and configure the pipeline for your chosen content niche.

In this step, get ready to:
  • Clone the FreeFaceless repository and create your environment file.
  • Install all Python dependencies with the setup script.
  • Customize your niche and video settings in config.yaml.
Clone FreeFaceless and set up the environment
  • Move to your Desktop by running this command in PowerShell:
cd ~/Desktop
  • Clone the FreeFaceless repository, move into it, and create your environment file by running these commands:
git clone https://github.com/nils44344/FreeFaceless.git
cd FreeFaceless
Copy-Item .env.example .env

What do these commands do?

  • git clone downloads the entire FreeFaceless project from GitHub to your Desktop.
  • cd FreeFaceless moves your terminal into the newly created project folder.
  • Copy-Item .env.example .env creates a fresh .env file from the project's template so you can add your own keys.
  • Confirm the clone worked by running:
ls

You should see files like .env, config.yaml, setup.ps1, and a src folder listed in the output.

Seeing a 'not recognized' or network error?

  • If git is not recognized, close and reopen PowerShell so your PATH picks up the Git installation from Step 1.
  • If you see a network error, check your internet connection and try the clone command again.

Help me troubleshoot the git clone command for FreeFaceless

Now you need to add your real API keys to the .env file so the pipeline can connect to Groq and Pexels.

  • Open .env in Notepad by running:
notepad .env
  • Replace the placeholder values with your real API keys so the file looks like this:
GROQ_API_KEY=your_groq_key_here
PEXELS_API_KEY=your_pexels_key_here

What are these environment variables?

  • GROQ_API_KEY lets the pipeline call Groq's AI to generate video scripts using the Llama model.
  • PEXELS_API_KEY lets the pipeline download stock video clips to use as background footage.
  • Paste your real Groq key after GROQ_API_KEY= (no spaces around the equals sign).
  • Paste your real Pexels key after PEXELS_API_KEY=.
  • Save the file with Ctrl+S and close Notepad.

✔️ Awesome, I've got everything!

Great. Double check you have saved your .env file with both keys filled in.

ⓧ I'd like to double check the full code

Your .env file should have exactly two lines (with your own keys replacing the placeholders):

GROQ_API_KEY=your_groq_key_here
PEXELS_API_KEY=your_pexels_key_here
Install dependencies

The FreeFaceless project includes a setup script that creates an isolated Python environment and installs all required packages automatically.

  • Install everything into a local virtual environment by running the setup script:
.\setup.ps1

What does this script do?

The setup.ps1 script creates a .venv folder containing a self-contained Python environment. It then installs all the Python packages the pipeline needs (Groq SDK, edge-tts, faster-whisper, Pexels client, and more) into that folder.

This keeps your project's packages separate from your system Python, so nothing conflicts with other projects on your machine.

  • Wait for the script to finish. It may take 2-3 minutes as it downloads packages.
  • Confirm the virtual environment was created by running:
ls .venv

You should see folders like Scripts and Lib listed inside .venv.

Script won't run or shows a red error?

  • If you see an execution policy error, run Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser and then try .\setup.ps1 again.
  • If you see a Python-related error, confirm python --version still returns 3.11 or higher. If not, revisit Step 1.

Help me fix the setup.ps1 error in FreeFaceless

Customize your niche in config.yaml

The config.yaml file controls what kind of videos your pipeline generates. You will set your content niche, voice style, caption format, and upload privacy level here.

  • Open config.yaml in Notepad by running:
notepad config.yaml
  • Replace the contents of the file with the following configuration:
niche: "fascinating educational facts (science, history, nature, space, human body)"
voice:
  voice: en-US-ChristopherNeural
captions:
  font: "Anton"
  words_per_caption: 3
video:
  width: 1080
  height: 1920
upload:
  privacy: "private"

What do these settings control?

  • niche tells the AI what topics to write scripts about. You can change this to anything that interests you.
  • voice sets the neural text-to-speech voice. en-US-ChristopherNeural is a clear, natural-sounding male voice.
  • captions controls the karaoke-style subtitles. Anton is a bold display font, and 3 words per caption keeps text readable on mobile.
  • video sets the output resolution to 1080x1920 (vertical format for YouTube Shorts).
  • privacy is set to private so your first test video does not go public before you review it.

Choose a niche that excites you

High-performing niches on YouTube Shorts include educational facts, finance tips, motivational content, tech explainers, and history stories. Feel free to replace the niche line with your own topic.

  • Save the file with Ctrl+S and close Notepad.
  • Confirm your changes saved by running:
Get-Content config.yaml

You should see your niche, voice, captions, video, and upload settings printed in the terminal.

Config file looks empty or has errors?

  • Make sure you saved the file in Notepad before closing it.
  • YAML is sensitive to indentation. Each nested key must be indented with exactly two spaces, not tabs.
  • If you accidentally deleted content, copy the full configuration from the double-check tab below and paste it into config.yaml.

Help me fix my config.yaml formatting

✔️ Awesome, I've got everything!

Great. Double check you have saved config.yaml with your chosen niche and all settings filled in.

ⓧ I'd like to double check the full code

Your config.yaml should look like this (your niche may differ if you chose a custom topic):

niche: "fascinating educational facts (science, history, nature, space, human body)"
voice:
  voice: en-US-ChristopherNeural
captions:
  font: "Anton"
  words_per_caption: 3
video:
  width: 1080
  height: 1920
upload:
  privacy: "private"

Your pipeline is fully configured. Next up, you will run it and generate your first AI-powered YouTube Short from scratch.

Generate Your First YouTube Short

Your pipeline is fully configured with API keys, a virtual environment, and your niche settings. Now it is time to see everything in action.

In this step, you will authorize your YouTube account, run the full video generation pipeline, and watch your first AI-created Short come to life on your screen.

In this step, get ready to:
  • Authorize the pipeline to upload to your YouTube channel.
  • Generate a complete YouTube Short without uploading it.
  • Review the final video to check quality.
Authorize YouTube (one-time setup)

Before the pipeline can upload videos on your behalf, it needs permission from your Google account. This is a one-time OAuth flow that saves a token file locally so future runs skip this step.

  • In PowerShell, make sure you are inside the FreeFaceless folder.
  • Authorize the pipeline to access your YouTube channel by running this command:
.\.venv\Scripts\python -m src.authorize

What does this command do?

This launches a browser window where you sign in with your Google account and grant the pipeline permission to upload videos to your YouTube channel.

Once you approve, a token file is saved in your project folder. Future pipeline runs use this token automatically without asking again.

  • A browser window will open automatically. Sign in with the Google account that owns your YouTube channel.
  • If you see a warning that the app is not verified, click Advanced and then Go to YT-Shorts-Bot (unsafe).
  • Grant the requested YouTube permissions and close the browser tab when it confirms success.

Why does it say "unsafe"?

Google shows this warning because your OAuth app has not gone through their verification process. This is normal for personal-use apps that only you will use.

It is safe to proceed because you created the credentials yourself in Google Cloud Console.

  • Back in PowerShell, you should see a confirmation message indicating authorization was successful.

Browser did not open?

Make sure client_secrets.json is in the FreeFaceless folder (not a subfolder). The pipeline looks for it in the project root.

If you see a file-not-found error, double-check that you renamed the downloaded JSON file to exactly client_secrets.json.

Help me troubleshoot

Run a dry run (generate video without uploading)

The pipeline has six stages: script generation, voiceover synthesis, caption timing, stock footage download, video assembly, and upload. By using the --no-upload flag, you skip the final upload stage so you can review the video before it touches your channel.

  • Generate your first Short by running this command:
.\.venv\Scripts\python -m src.pipeline --no-upload

What happens during the pipeline run?

  • Groq generates a script using the llama-3.3-70b-versatile model based on your niche.
  • edge-tts synthesizes a neural voiceover using the en-US-ChristopherNeural voice.
  • faster-whisper generates word-level caption timing. On your first run, it downloads a speech model (this may take a minute).
  • The Pexels Videos API provides stock clips that match your script's topics.
  • FFmpeg assembles everything into a final 1080x1920 video with karaoke-style captions.

How long does this take?

The first run typically takes 2-5 minutes depending on your internet speed. Most of the time is spent downloading stock clips from Pexels and (on first run only) downloading the caption-timing model.

Subsequent runs are faster because the model is cached locally.

  • Wait for the pipeline to complete. You should see progress messages for each stage in your terminal.
  • When it finishes, note the output path printed in the terminal. It follows the pattern output\<timestamp>_<topic>\final.mp4.

Seeing a rate limit or API error?

If Groq returns a 429 error, you have hit the free tier rate limit. Wait a minute and try again. The free tier is sufficient for one video at a time.

If you see a Pexels error, confirm your PEXELS_API_KEY in the .env file has no extra spaces or quotes around it.

Help me fix this API error

Review your generated Short

Your first AI-generated video is now sitting in the output folder. Time to watch it and check quality before deciding whether to publish.

  • Open File Explorer and navigate to the FreeFaceless\output folder.
  • Open the timestamped subfolder (it will be named something like 20260609_120000_fascinating_facts).
  • Double-click final.mp4 to play it in your default video player.

Your video should be approximately 55 seconds long and play in portrait orientation (1080x1920).

  • Check: Does the AI-written script make sense and sound natural?
  • Check: Is the voiceover clear and well-paced?
  • Check: Do the stock video clips roughly match the content being discussed?
  • Check: Are the captions synced with the voiceover?

Not happy with the result?

Each run generates a completely unique video. Run the pipeline command again to get a different script, different footage, and different voiceover pacing. The AI generates fresh content every time.

Your first AI-generated YouTube Short is ready. Next up, you will learn about YouTube monetization requirements and upload the video to your channel for real.

Go Live and Understand Monetization

You have a fully working video pipeline that can produce Shorts on command. Before you upload your first public video, you need to understand how YouTube monetization works and what rules apply to AI-generated content.

In this step, you will learn the YouTube Partner Program requirements, update your pipeline to upload publicly, and confirm your first Short lands in YouTube Studio.

In this step, get ready to:
  • Learn the YouTube Partner Program thresholds and AI disclosure rules.
  • Upload your first Short to your YouTube channel.
  • Verify the upload in YouTube Studio.
Understand the YouTube Partner Program requirements

To earn money from YouTube Shorts, your channel must qualify for the YouTube Partner Program. There are specific subscriber and view thresholds you need to hit.

  • For Shorts monetization, you need 1,000 subscribers AND 10 million valid public Shorts views in the last 90 days.
  • For long-form video monetization, the alternative path is 1,000 subscribers AND 4,000 valid public watch hours in the last 12 months.
  • YouTube pays creators 45% of the net Shorts ad revenue allocated to monetizing creators.
  • For long-form watch page ads, YouTube pays 55% of net ad revenue.

Why Shorts over long-form?

10 million Shorts views in 90 days sounds like a lot, but Shorts have viral potential that long-form videos typically don't. With consistent daily posting, individual Shorts can reach hundreds of thousands of views through the algorithm.

The 4,000 watch-hours path requires sustained viewership over 12 months, which is harder to achieve with automated content.

Know the AI disclosure and content rules

YouTube has specific policies around AI-generated content that you must follow to stay eligible for monetization.

  • YouTube requires creators to disclose AI-generated or meaningfully AI-altered content. During upload in YouTube Studio, go to the Attributes section and select Yes under AI use for videos with AI voiceovers. Failing to disclose can result in penalties or suspension from the Partner Program.
  • Your content must be "materially varied" between videos. The AI pipeline generates unique scripts each time, satisfying this requirement as long as you vary your topics.
  • Avoid mass-produced or repetitive content that adds no educational or entertainment value. YouTube's inauthentic content policy can remove monetization from your entire channel.

Always disclose AI-generated voiceovers

When uploading any video produced by this pipeline, always select Yes in the AI use field under Attributes in YouTube Studio. This applies to your AI voiceover, AI-generated scripts, and the automated assembly process.

Creators who consistently fail to disclose may face content removal or suspension from the YouTube Partner Program.

Upload your first Short for real

Your previous run used the --no-upload flag to generate a video without publishing. Now you will switch the pipeline to upload mode.

  • In config.yaml, find the upload section near the bottom of the file.
  • Find this line:
  privacy: "private"
  • Change "private" to "public" so the line now looks like this:
  privacy: "public"

Keep it private for testing

If you are not ready to go public yet, you can leave privacy set to "private". Your Short will still upload to YouTube but only you can see it in YouTube Studio.

  • Save config.yaml.
  • Run the full pipeline (generate + upload) by running this command in PowerShell:
..\.venv\Scripts\python -m src.pipeline

What does this command do?

Without the --no-upload flag, the pipeline runs all six stages: script generation with Groq, voiceover with edge-tts, caption timing with faster-whisper, stock footage from Pexels, video assembly with FFmpeg, and finally uploads the finished Short to your YouTube channel.

The pipeline takes 2-3 minutes to complete. You will see progress output for each stage in the terminal.

Upload failed or timed out?

Make sure your internet connection is stable. The final MP4 file needs to upload to YouTube's servers.

If you see an authentication error, your OAuth token may have expired. Run ..\.venv\Scripts\python -m src.authorize again to refresh it.

Help me troubleshoot my pipeline upload error.

Verify your upload in YouTube Studio
  • Open your browser and go to studio.youtube.com.
  • Click Content in the left sidebar.
  • Confirm your new Short appears in the video list with an auto-generated title, description, and tags.

Your Short should show as either a public or private video depending on what you set in config.yaml. The pipeline auto-generates SEO metadata (title, description, tags) for each video.

Don't see your Short in YouTube Studio?

Check the terminal output from the pipeline. Look for a success message at the end confirming the upload completed.

If the pipeline finished but the video is not visible, give YouTube a minute or two to process. Newly uploaded videos sometimes take a moment to appear in the content list.

My pipeline says it uploaded but I can't find my video in YouTube Studio.

✔️ Awesome, I've got everything!

Great. Double check you have saved config.yaml with your updated privacy setting.

ⓧ I'd like to double check the full code

Here is the complete config.yaml as it should look now:

niche: "fascinating educational facts (science, history, nature, space, human body)"
voice:
  voice: en-US-ChristopherNeural
captions:
  font: "Anton"
  words_per_caption: 3
video:
  width: 1080
  height: 1920
upload:
  privacy: "public"

Your channel now has its first AI-generated Short live (or staged privately). Next up, the Secret Mission takes this to the next level by automating daily publishing so your channel grows without you lifting a finger.

Secret mission

Automate Daily Posting with Task Scheduler

Your pipeline generates videos on demand. But what if it could run itself every single day, publishing a new Short to your channel while you sleep? In this secret mission, you will wire up Windows Task Scheduler to trigger the pipeline automatically, turning your PC into a fully hands-off content machine.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely on free-tier services and local files. There are no ongoing costs.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

  • FreeFaceless repository folder (local clone, virtual environment, generated videos).
  • Windows Task Scheduler task ("YouTube Shorts Daily").
  • Groq API account and key (free tier, no charges).
  • Pexels API account and key (free, no charges).
  • Google Cloud project with YouTube Data API v3 enabled (free upload quota).

Keep everything running

No action needed. Choose this if you are still actively building or want your channel to keep publishing daily.

  • Task Scheduler continues publishing a new Short every day at the time you configured.
  • Monitor your Groq usage in the console. The free tier is rate-limited but sufficient for one video per day.
  • Generated videos accumulate in the output folder. Periodically delete old subfolders to free disk space.
  • Python, FFmpeg, and Git remain installed on your machine.

Pause - I'll come back to this later

Shut down the automated publishing to free up background resources while keeping all files and credentials intact.

  • Disable the Task Scheduler task by running this command in PowerShell:
Disable-ScheduledTask -TaskName "YouTube Shorts Daily"

Your pipeline files, API keys, and configuration remain on disk.

  • When you are ready to resume, re-enable the task by running:
Enable-ScheduledTask -TaskName "YouTube Shorts Daily"

Delete - I don't want to use this again

Remove all project resources and start fresh. Follow each step below.

  • Delete the Task Scheduler task by running this command in PowerShell:
Unregister-ScheduledTask -TaskName "YouTube Shorts Daily" -Confirm:$false
  • Delete the FreeFaceless folder and all generated videos by running this in the parent directory where you cloned the repo:
Remove-Item -Recurse -Force .\FreeFaceless
  • Delete the client_secrets.json file if you saved it outside the FreeFaceless folder.
  • Revoke your Groq API key. Open the Groq Console at https://console.groq.com, navigate to API Keys, and delete the key you created for this project.
  • Regenerate or deactivate your Pexels API key. Visit https://www.pexels.com/api/, sign in, and use the key management options to change your key so the old one stops working.
  • Delete the Google Cloud project. Go to the Google Cloud Console, open IAM & Admin, then click Settings. Click Shut down, enter your project ID, then click Shut down again to confirm. This disables the YouTube Data API v3 credentials and removes all project resources after a 30-day recovery period.

That's a Wrap!

That's a Wrap!

Nice work! You just built a fully automated YouTube Shorts factory on your Windows PC, from AI scriptwriting all the way through to upload.

You've learned how to:

  • Set up a complete Python-based video automation pipeline using FreeFaceless, wiring together free API keys from Groq, Pexels, and the YouTube Data API v3.
  • Generated your first faceless YouTube Short end-to-end: AI script, neural voiceover, stock footage, karaoke-style captions, and final assembly into a 1080x1920 MP4.
  • Uploaded your first Short to YouTube Studio with auto-generated SEO metadata, and learned the YouTube Partner Program requirements for Shorts monetization.
  • Secret Mission: Automated daily publishing with Windows Task Scheduler for fully hands-off channel growth.

Ready to quiz yourself?