Building a Faceless Content Empire: A Deep Dive into the MoneyPrinterV2 Architecture
How Python, LLMs, and Browser Automation work together to generate, assemble, and publish media on autopilot
If you have ever wondered how automated, “faceless” YouTube Shorts and Twitter accounts generate endless streams of content, MoneyPrinterV2 is a masterclass in how it is done under the hood. At its core, this project is a robust, end-to-end Python orchestration pipeline. It takes a simple configuration—like a topic niche and a language—and seamlessly coordinates artificial intelligence, media processing, and web automation to research, build, and publish complete digital assets without human intervention.
The magic of this codebase lies in how it glues together state-of-the-art AI tools. When you kick off a YouTube Shorts workflow, the system asks a Large Language Model (like a local Ollama instance) to brainstorm a specific video topic, write a concise script, and generate SEO-optimized metadata. It then prompts an image-generation API to create relevant visuals, uses a Text-to-Speech (TTS) engine to narrate the script, and feeds the audio through Whisper or AssemblyAI to generate perfectly timed subtitles. Finally, a video processing library (moviepy) dynamically crops the images to a vertical format, mixes in background music, burns in the subtitles, and stitches it all into a polished MP4.
But generating the media is only half the battle; MoneyPrinterV2 also handles the distribution. Rather than relying on restrictive or expensive official platform APIs, the pipeline leverages Selenium and headless Firefox profiles to mimic human behavior. The platform clients navigate directly to the YouTube Studio or Twitter compose interfaces, upload the media, fill out the forms (down to clicking the “Not made for kids” radio buttons), and publish the content. A lightweight, local JSON caching system acts as the project’s memory, keeping track of which videos or tweets have been published to which accounts, allowing the system to run interactively via a CLI or infinitely via scheduled cron jobs.
Beyond standard content creation, the repository also features dedicated modules for monetization and lead generation. The Affiliate Marketing (AFM) module can scrape Amazon product features to auto-generate and tweet persuasive sales pitches containing your affiliate links. Meanwhile, the Outreach module compiles and executes a Go-based Google Maps scraper to hunt down local business leads, crawls their websites for contact information, and sends automated, personalized cold emails. Altogether, the codebase is a fascinating study in system integration, combining the creative power of AI with the brute force of browser automation.
# file path: src/main.py
import schedule
import subprocess
from art import *
from cache import *
from utils import *
from config import *
from status import *
from uuid import uuid4
from constants import *
from classes.Tts import TTS
from termcolor import colored
from classes.Twitter import Twitter
from classes.YouTube import YouTube
from prettytable import PrettyTable
from classes.Outreach import Outreach
from classes.AFM import AffiliateMarketing
from llm_provider import list_models, select_model, get_active_modelThe imports at the top of src/main.py assemble the tools the entrypoint needs to orchestrate the AffiliateMarketing workflow: schedule brings in the lightweight job scheduler so main can run periodic or timed runs of the pipeline; subprocess is available to spawn external processes used during media generation or helper tools; art supplies console banner/art utilities used to present startup UI; the cache module provides access to persistent, account-scoped storage so main can load and persist account and artifact state; utils and config expose common helper routines and runtime configuration flags that control preflight behavior and logging; status supplies the project’s standardized info/warning/success logging helpers used throughout the orchestration; uuid4 is used to generate unique identifiers for new accounts or artifacts; constants centralizes shared constants and option lists used when presenting menus or driving control flow. The TTS class plugs in text-to-speech functionality so main can ask the pipeline to synthesize audio; termcolor.colored is used to colorize console output when main prints menus and status lines; Twitter and YouTube classes are the platform clients main uses to publish or preview generated content; PrettyTable is used to render account lists and summaries in a readable table for interactive flows; Outreach provides the outreach/email client used by the marketing flow to reach partners or affiliates; AffiliateMarketing is the high-level orchestrator that main invokes to actually generate and share pitches. Finally, llm_provider utilities (list_models, select_model, get_active_model) let main enumerate and choose the language-model provider before delegating content generation to the AffiliateMarketing component. Compared with other entry and helper modules, main imports many of the same logging, cache, TTS and platform client pieces but additionally pulls in scheduling, art, constants, Outreach and the fuller set of llm_provider helpers because its role is interactive orchestration and end-to-end sequencing rather than a single-platform helper.
# file path: src/main.py
def main():
valid_input = False
while not valid_input:
try:
info("\n============ OPTIONS ============", False)
for idx, option in enumerate(OPTIONS):
print(colored(f" {idx + 1}. {option}", "cyan"))
info("=================================\n", False)
user_input = input("Select an option: ").strip()
if user_input == '':
print("\n" * 100)
raise ValueError("Empty input is not allowed.")
user_input = int(user_input)
valid_input = True
except ValueError as e:
print("\n" * 100)
print(f"Invalid input: {e}")
if user_input == 1:
info("Starting YT Shorts Automater...")
cached_accounts = get_accounts("youtube")
if len(cached_accounts) == 0:
warning("No accounts found in cache. Create one now?")
user_input = question("Yes/No: ")
if user_input.lower() == "yes":
generated_uuid = str(uuid4())
success(f" => Generated ID: {generated_uuid}")
nickname = question(" => Enter a nickname for this account: ")
fp_profile = question(" => Enter the path to the Firefox profile: ")
niche = question(" => Enter the account niche: ")
language = question(" => Enter the account language: ")
account_data = {
"id": generated_uuid,
"nickname": nickname,
"firefox_profile": fp_profile,
"niche": niche,
"language": language,
"videos": [],
}
add_account("youtube", account_data)
success("Account configured successfully!")
else:
table = PrettyTable()
table.field_names = ["ID", "UUID", "Nickname", "Niche"]
for account in cached_accounts:
table.add_row([cached_accounts.index(account) + 1, colored(account["id"], "cyan"), colored(account["nickname"], "blue"), colored(account["niche"], "green")])
print(table)
info("Type 'd' to delete an account.", False)
user_input = question("Select an account to start (or 'd' to delete): ").strip()
if user_input.lower() == "d":
delete_input = question("Enter account number to delete: ").strip()
account_to_delete = None
for account in cached_accounts:
if str(cached_accounts.index(account) + 1) == delete_input:
account_to_delete = account
break
if account_to_delete is None:
error("Invalid account selected. Please try again.", "red")
else:
confirm = question(f"Are you sure you want to delete '{account_to_delete['nickname']}'? (Yes/No): ").strip().lower()
if confirm == "yes":
remove_account("youtube", account_to_delete["id"])
success("Account removed successfully!")
else:
warning("Account deletion canceled.", False)
return
selected_account = None
for account in cached_accounts:
if str(cached_accounts.index(account) + 1) == user_input:
selected_account = account
if selected_account is None:
error("Invalid account selected. Please try again.", "red")
main()
else:
youtube = YouTube(
selected_account["id"],
selected_account["nickname"],
selected_account["firefox_profile"],
selected_account["niche"],
selected_account["language"]
)
while True:
rem_temp_files()
info("\n============ OPTIONS ============", False)
for idx, youtube_option in enumerate(YOUTUBE_OPTIONS):
print(colored(f" {idx + 1}. {youtube_option}", "cyan"))
info("=================================\n", False)
user_input = int(question("Select an option: "))
tts = TTS()
if user_input == 1:
youtube.generate_video(tts)
upload_to_yt = question("Do you want to upload this video to YouTube? (Yes/No): ")
if upload_to_yt.lower() == "yes":
youtube.upload_video()
elif user_input == 2:
videos = youtube.get_videos()
if len(videos) > 0:
videos_table = PrettyTable()
videos_table.field_names = ["ID", "Date", "Title"]
for video in videos:
videos_table.add_row([
videos.index(video) + 1,
colored(video["date"], "blue"),
colored(video["title"][:60] + "...", "green")
])
print(videos_table)
else:
warning(" No videos found.")
elif user_input == 3:
info("How often do you want to upload?")
info("\n============ OPTIONS ============", False)
for idx, cron_option in enumerate(YOUTUBE_CRON_OPTIONS):
print(colored(f" {idx + 1}. {cron_option}", "cyan"))
info("=================================\n", False)
user_input = int(question("Select an Option: "))
cron_script_path = os.path.join(ROOT_DIR, "src", "cron.py")
command = ["python", cron_script_path, "youtube", selected_account['id'], get_active_model()]
def job():
subprocess.run(command)
if user_input == 1:
schedule.every(1).day.do(job)
success("Set up CRON Job.")
elif user_input == 2:
schedule.every().day.at("10:00").do(job)
schedule.every().day.at("16:00").do(job)
success("Set up CRON Job.")
else:
break
elif user_input == 4:
if get_verbose():
info(" => Climbing Options Ladder...", False)
break
elif user_input == 2:
info("Starting Twitter Bot...")
cached_accounts = get_accounts("twitter")
if len(cached_accounts) == 0:
warning("No accounts found in cache. Create one now?")
user_input = question("Yes/No: ")
if user_input.lower() == "yes":
generated_uuid = str(uuid4())
success(f" => Generated ID: {generated_uuid}")
nickname = question(" => Enter a nickname for this account: ")
fp_profile = question(" => Enter the path to the Firefox profile: ")
topic = question(" => Enter the account topic: ")
add_account("twitter", {
"id": generated_uuid,
"nickname": nickname,
"firefox_profile": fp_profile,
"topic": topic,
"posts": []
})
else:
table = PrettyTable()
table.field_names = ["ID", "UUID", "Nickname", "Account Topic"]
for account in cached_accounts:
table.add_row([cached_accounts.index(account) + 1, colored(account["id"], "cyan"), colored(account["nickname"], "blue"), colored(account["topic"], "green")])
print(table)
info("Type 'd' to delete an account.", False)
user_input = question("Select an account to start (or 'd' to delete): ").strip()
if user_input.lower() == "d":
delete_input = question("Enter account number to delete: ").strip()
account_to_delete = None
for account in cached_accounts:
if str(cached_accounts.index(account) + 1) == delete_input:
account_to_delete = account
break
if account_to_delete is None:
error("Invalid account selected. Please try again.", "red")
else:
confirm = question(f"Are you sure you want to delete '{account_to_delete['nickname']}'? (Yes/No): ").strip().lower()
if confirm == "yes":
remove_account("twitter", account_to_delete["id"])
success("Account removed successfully!")
else:
warning("Account deletion canceled.", False)
return
selected_account = None
for account in cached_accounts:
if str(cached_accounts.index(account) + 1) == user_input:
selected_account = account
if selected_account is None:
error("Invalid account selected. Please try again.", "red")
main()
else:
twitter = Twitter(selected_account["id"], selected_account["nickname"], selected_account["firefox_profile"], selected_account["topic"])
while True:
info("\n============ OPTIONS ============", False)
for idx, twitter_option in enumerate(TWITTER_OPTIONS):
The main function in src/main.py is the interactive CLI orchestrator that wires user choices into the higher-level automation pipeline of MoneyPrinterV2-main_cleaned: it repeatedly prints the OPTIONS menu using info, validates a non-empty numeric selection, and then dispatches to provider-specific workflows. If the user chooses the YouTube Shorts Automater, main calls get_accounts with “youtube” to load the cached YouTube accounts; if none exist
# file path: src/status.py
from termcolor import coloredThe code brings in the colored function from the termcolor library so the status utilities can emit ANSI-colored terminal output; colored is the mechanism that the status module uses to make error, success, info and warning messages visually distinct in console logs. Within the orchestration pipeline this supports the file’s role of standardizing runtime alerts and prompts so callers across main and subcomponents get consistently formatted messages; for example, the success function uses colored to print green success lines (optionally with an emoji). You’ll see the same import used elsewhere in the project, which reflects a project-wide convention to rely on termcolor/colored for terminal message styling.
# file path: src/status.py
def success(message: str, show_emoji: bool = True) -> None:
emoji = "✅" if show_emoji else ""
print(colored(f"{emoji} {message}", "green"))success is a small, centralized status helper used by the orchestration layer to signal successful operations to the operator; it accepts a human-readable message and an optional flag to include a check-mark emoji, chooses the emoji when requested, and writes a colorized green line to the console. Within the pipeline it is called by many higher-level components—main, main_part1, close_running_selenium_instances, YouTube.generate_video and upload_video flows, Outreach, Twitter posting flows, AffiliateMarketing, TTS usage, and various cache-and-file helpers—to consistently report success states after tasks complete. The function performs no persistence, network activity, or branching logic beyond the emoji toggle, returns nothing, and thus serves purely as a standardized, visually distinct success reporter that complements the colorized info, error, warning and question utilities used across the project.
# file path: src/status.py
def info(message: str, show_emoji: bool = True) -> None:
emoji = "ℹ️" if show_emoji else ""
print(colored(f"{emoji} {message}", "magenta"))info provides a centralized way for the orchestration layer to emit informational runtime messages to the console. It decides whether to prepend an info emoji based on the show_emoji flag and then prints the message in magenta using the project’s colored-print helper, producing a colorized, human-friendly status line; the function returns None and its only side effect is console output. Many callers use info to announce high-level steps and state transitions — for example main_part1 uses it to draw menu separators, fetch_songs and Outreach.run_scraper_with_args_for_30_seconds use it to announce ongoing operations, YouTube._persist_image and generate_script_to_speech call it (often gated by get_verbose) to report file writes, and AffiliateMarketing.scrape_product_information uses it to log scraped details — so info standardizes how those components communicate progress, while following the same pattern as success, warning and error (which differ only in color and emoji) and contrasting with question (which uses the same styling but returns user input instead of printing).
