Program for automatic video assembly (local, for personal use)

Budget: 27000 UAH Deadline: 14 days

Manual assembly of 50+ files a day is a waste of time and money.
I automate video assembly for any scenarios: ffmpeg/moviepy, ElevenLabs/LLM, stock APIs.
Ready MP4 on disk, GUI on PyQt, no database — only local files + JSON cache with auto-cleaning.
27,000 UAH, 14 days. Result: you run it — you get the finished video.

Budget: 27000 UAH Deadline: 14 days

Good day! I have been gathering similar pipelines in Python: script generation via LLM API, voiceover from ElevenLabs through API, automatic footage selection from free stock sources, and assembly into MP4 using ffmpeg/moviepy, all in a simple window under Windows (keys in settings). A faceless format with voiceover and scene changes is exactly what I do. I am ready to take this on, approximately 14 days. One question regarding the video footage: are Pexels/Pixabay stocks via API acceptable, or do you need a specific source for the clips?

Budget: 27000 UAH Deadline: 14 days

Sergey, good afternoon.

Regarding your points. Examples: I don't have a public case specifically for video assembly - I've done that with internal scripts for clients and can't show someone else's work. From the open side - accessibilityscanner.top, my working website audit service: a queue of tasks, a bunch of external APIs, and a ready file at the output; architecturally, it's the same conveyor you need, just with a report at the end instead of MP4. I work constantly with OpenAI/Anthropic API, know ffmpeg and moviepy, and for ElevenLabs, the endpoint with-timestamps will be useful - it provides the timings of words, just right for your subtitles. GUI: a simple window on Tkinter with ttk, without heavy Qt, I will build an exe through PyInstaller - double-click and it works. Database: SQLite will be enough, one local file - it will contain the history of used clips and cache accounting (date, size), and it will also have auto-cleaning when exceeding the limit. Deadline and cost: 14 days, 27,000 UAH.

Now, where it's easy to make a mistake in this technical specification. The "no voiceover" option breaks the basic timing scheme: in normal mode, the length of the scene is dictated by the audio, but here it is absent, and the duration of frames needs to be calculated from the text and settings. That is, the cutting engine needs two branches of timeline calculation with a common assembler; otherwise, the option will end up being a workaround on top of the existing code. I would immediately make the timeline a separate layer: first, the layout of scenes (from audio or from text), then downloading and cutting under it. This also simplifies the "photo only" mode - there, only the source of frames changes, not the logic.

One question: in "photo only" mode, should the intro teaser also be assembled from photos with enhanced motion, or is a teaser not needed in this mode?

Budget: 27000 UAH Deadline: 20 days

Sergiy, the task is clear: a local generator of faceless videos with LLM, ElevenLabs, searching through 6+ open APIs, and assembling via ffmpeg/moviepy. I have already worked on similar pipelines: API integrations, modular architecture, media processing, caching, and automatic cleanup of temporary files. For such a project, I suggest Tkinter or PyQt, and for the state — local files or SQLite, without unnecessary complexity. I can implement a GUI, fallback search, frame checking, and post-processing of overlays. I am ready to discuss the plan and stages.

Price: 20,000 UAH
Deadline: 20 days

Budget: 27000 UAH Deadline: 22 days

Hello! I worked on a similar project, but in a simplified version: not from scratch with text, but rather — you upload a large video (for example, a recording of a match or a stream), and you get a cut of the main moments in return.

Here's how it works: a Python script analyzes the video through the Gemini API (recognizes key moments based on audio/video content), cuts the necessary segments using ffmpeg, and if needed, adds subtitles/formats for vertical format (TikTok/Reels) — and delivers the finished short clips.

Your case (script → voiceover → video selection from archives → editing) is more complex in composition, but architecturally similar: it's also a pipeline of several AI stages + ffmpeg for assembly. I can adapt it to your specific flow — just for local execution on Windows, without a website and users, as you requested.

Budget: 27000 UAH Deadline: 8 days

Hello, Sergey! The technical specification is simply magnificent - maximally clear, detailed, and well thought out.

I am Nina, the manager of the IT team at Valflow. The architecture and development of your program will be handled by Valentin - a Senior Python developer. Automation of content, working with media (FFmpeg/MoviePy), integrations with ElevenLabs, LLM API, and stock services are his areas of expertise.

Answers to your questions from the technical specification:

1. Experience and similar solutions:
Valentin regularly develops automated systems for generating video and audio content (including working with the ElevenLabs API, OpenAI/Claude for scripts, automatic text splitting into scenes, processing video footage through FFmpeg/MoviePy, and overlaying cinematic effects/overlays).

2. GUI proposal:
We recommend implementing the interface in PyQt6 (or CustomTkinter). This will provide a modern, stylish, and user-friendly desktop interface (dark theme, transparency sliders for overlays, dropdown lists with dynamic loading of ElevenLabs voices, a generation progress bar, and a real-time log window). All control will be exclusively through buttons and settings; you won't need to touch the code.

3. Database:
We will use a lightweight local SQLite (does not require additional software installation). It is ideal for:
* Storing IDs and hashes of already used clips/photos (to avoid duplicates and ensure uniqueness);
* Cache settings and history of generated videos.

4. Modularity and code:
The code will be clean, modular (each source will be a separate isolated class/module), and equipped with clear comments + a README file. You will receive fully open source code without any restrictions, as well as a compiled executable version for one-click launch.

Deadline: 7-10 days.
Cost: 27,000 UAH.

We are ready to start working this week and create a convenient, powerful tool for you! Expand

Budget: 25999 UAH Deadline: 10 days

Hello! The technical specification is well-developed. I understand the task: a local auto-assembly pipeline for faceless videos with LLM, ElevenLabs, footage selection, and cache cleaning is needed. I'm ready to take it on. Below, I've outlined how I will implement the technical requirements and address any non-obvious vulnerabilities.

How it works (step by step)
1. Interface and Database
Input. The program starts with a double click. This is a fully autonomous .exe file (I will build it using PyInstaller). Inside, it runs a modern GUI on CustomTkinter (the window does not freeze during rendering, with necessary sliders and settings).
Database. I use an embedded SQLite. No server is needed. The database works only for two tasks: storing the history of clips (excluding duplicates in new videos) and tracking cache size (auto-cleaning when exceeding the limit).
2. Architecture and Render (FFmpeg)
Crash protection. The assembly goes directly through FFmpeg CLI, not through MoviePy. The MoviePy library consumes all RAM when applying overlays and the Ken Burns effect (zoom). Directly calling FFmpeg will protect the PC and significantly speed up rendering.
Quick search. Polling 6+ sources (Pexels, Archive, NASA, and others) is launched asynchronously (via asyncio). The output is gathered in a couple of seconds, and the code does not hang for minutes waiting for each site.
3. Vulnerability solution (mode "Without Voiceover")
Problem. Without an audio file, the basic timing calculation of scenes breaks (usually, the length of the frame is calculated from the length of the audio track).
Solution. I am implementing an independent module called Timeline Manager.
Audio mode → the script calculates the length from the sound.
No audio mode → the script relies on the amount of text in the scene and specified limits (4-6 seconds per frame). Frame changes will be precise in any scenarios without hacks on top of the existing code.
4. LLM budget savings
API balance protection. Checking frames through a Vision model (up to 3 steps) is expensive.
How it works. I set up a local cache of image hashes. The program checks the image hash before sending a request to LLM. The neural network does not spend your tokens on checking footage it has already analyzed before.

Conditions
Deadline: 10-14 days.
Budget: 27,000 UAH.
I am ready to discuss the details in private messages and start working. Expand

Budget: 27000 UAH Deadline: 14 days

Hello! I have experience in developing Python scripts for media automation (FFmpeg, MoviePy), generating audio through ElevenLabs, and working with APIs (OpenAI/Anthropic, stock services).

Answers to your questions:

- GUI proposal: CustomTkinter (or PyQt6). This will provide a modern, dark interface with all buttons, sliders, overlays, a progress bar, and the ability to compile the program into a convenient .exe for Windows.
- Database: we will use the built-in SQLite. It does not require the installation of additional servers and is needed solely for storing hashes/IDs of already used clips (to make the videos unique and avoid repetition) and your settings.
- Technical nuance of rendering: to prevent the program from "crashing" due to memory leaks when overlaying overlays and the Ken Burns effect, we will form the logic in Python, and the final build will be done directly through FFmpeg CLI.

Execution conditions:

- Cost: 27,000 UAH
- Deadline: 14 days

I am ready to discuss the project in more detail in the chat and start working! Expand

Budget: 27000 UAH Deadline: 9 days

Hello! The technical specifications are well-developed, and I'm ready to take on the project.

For the technical part, I suggest using PyQt6 for the interface to prevent the window from freezing during rendering, and a lightweight SQLite database — it will be perfect for storing the clip history without duplicates and efficiently clearing the cache. The main point here is in the rendering itself: it's better to do the assembly directly through the FFmpeg CLI rather than MoviePy, otherwise overlays and the Ken Burns effect will take forever to assemble and will consume a lot of RAM.

As for the timeline, I'm aiming for 7–9 days. If it's relevant, I can send a brief outline in a private message on how to optimize the 3-step frame check to avoid wasting the budget on LLM tokens.

Budget: 27000 UAH Deadline: 30 days

Such complex projects require not just coding, but proper architectural design to ensure the program remains fast, stable, and easily scalable. I propose to implement not a set of separate scripts, but a full-fledged Windows application with an intuitive graphical interface, where all daily actions are performed through buttons and settings without editing code. Special attention will be given to a modular structure, so that in the future, new media sources, LLMs, voice services, or additional modes of operation can be easily added without overhauling the entire system. All APIs will be isolated, settings will be moved to a separate interface, and logging will allow for quick identification of potential errors. Great emphasis will be placed on the quality of material selection, proper fallback operation between different archives, automatic cleanup of temporary files, optimization of disk space usage, and stable performance even during prolonged video creation. As a result, you will receive a fully autonomous tool that, after entering a topic or a ready script, will independently carry out the entire cycle from text creation to obtaining a finished MP4 without the need to use third-party online services or manual editing. Examples of work will be provided upon request.

Work plan:

Designing the application architecture and module structure.
Developing a graphical interface for all settings and modes of operation.
Integrating LLM for script generation and scene breakdown.
Connecting ElevenLabs with automatic retrieval of the voice list.
Implementing modules for searching photos and videos through the specified sources' APIs.
Developing logic for frame compliance checking through LLM with fallback.
Implementing intro generation, video composition, voiceover overlay, subtitles, and overlays.
Adding modes of operation, cache management, automatic cleanup of temporary files, and export settings.
Comprehensive testing, performance optimization, preparing README, and handing over the open source code. Expand

Budget: 27000 UAH Deadline: 14 days

Good day! We have experience in automating media content processing in Python using the MoviePy and OpenCV libraries. We will implement a local solution for Windows that will automatically edit the video sequence according to the audio track based on your script. We will ensure stable operation of the script with the ability to customize editing parameters for your tasks. We are ready to start the project implementation in the near future.

Budget: 27000 UAH Deadline: 8 days

Hello! The task is clear and fully aligns with my profile. I have extensive experience in developing local scripts in Python for automating media streams using ffmpeg, moviepy, and API integration for text generation and voiceover.

I am ready to implement the complete pipeline: from inputting the topic to the finished video file (script generation, speech synthesis, footage selection, and automatic editing).

Timeline: up to 10 days.
Budget: 27,000 UAH.

I am ready to discuss the details and start working.

Budget: 26000 UAH Deadline: 10 days

Good afternoon, Sergey. I am a Python developer with over 3 years of commercial experience, with experience in creating cross-platform (Windows / Mac OS (Intel) / Mac OS (ARM)) desktop applications using both Python (PyQT6) and React.js (Electron). I have also worked with ffmpeg when creating a Telegram bot for video uniqueness. Regarding the Eleven Labs API - I have my own project for learning English and German, where I use Eleven Labs for generating pronunciations of words and sentences, including using the Open AI API (GPT-4o mini model) for content generation (images and text). I have experience using LLM for AI analysis (developed a CRM with psychological profiling of leads based on AI, the project is in my portfolio), and I have also written parsers for web resources with anti-scraping protection, so the need to use stock/archive APIs will not be a problem. As for the GUI: I suggest PyQT6 (a lot of controls are needed, all covered by this framework), a database is needed: a local SQLite database will suffice for the registry of used media files, cache management, and generation history. Please write, I would be happy to implement the project.

Portfolio: Freelancehunt

Budget: 27000 UAH Deadline: 15 days

I studied the project description. It is necessary to develop not just a video generator, but a full-fledged desktop application in Python that automates the entire process of creating faceless videos: from script generation through LLM to finished MP4. This includes integration with ElevenLabs, a modular system for working with Pexels, Pixabay, Wikimedia, Archive.org, and other open archives, automatic selection of relevant content, frame checking through LLM, intro generation from the most important scenes, overlaying voiceovers, subtitles, overlays, and final assembly through FFmpeg.

I noticed several important points. For such a project, it is worth building a modular architecture from the start so that new content sources can be easily added or LLM can be replaced without reworking the entire program. Also, it is better to implement the search logic separately for each API, as they all work differently. For historical topics, it is necessary to provide a quality fallback to photographs with the Ken Burns effect, and to maximize video processing on FFmpeg — this will be faster and more stable than performing the entire assembly through MoviePy. For the history of used materials and cache management, it is advisable to use SQLite — this will help avoid duplicates and control disk cleanup.

I have experience in developing applications in Python, integrating REST APIs, automating complex processes, and creating programs with graphical interfaces. I write structured code with logic separation into modules so that the program can be easily maintained and expanded later without being tied to a single developer.

I propose to discuss the implementation details, determine the priority features for the first version, and agree on the project architecture. After that, we can start development in stages so that each module can be tested separately and achieve a stable result.

Budget: 27000 UAH Deadline: 14 days

Good day.

I have carefully analyzed the technical task. It is not about a separate Python script, but a full-fledged local video generation pipeline: script creation, voiceover, search for licensed content, frame compliance checking, editing, analytics of used materials, cache management, and a user-friendly Windows interface.

I suggest building the program modularly, so that in the future it will be possible to replace the LLM, add new archives, or change the voiceover method without rewriting the entire application.

How I will implement it

I propose to make the interface using PySide6. It is better suited for a full-fledged Windows program than the basic Tkinter and will allow for convenient placement of:

a topic field or insertion of a ready script;
selection of an ElevenLabs voice loaded via API;
video length and format;
“photo only” and “no voiceover” modes;
video material share;
subtitle settings;
overlay selection and intensity adjustment;
result and temporary file folders;
cache management;
progress tracking and clear error logs.

The main process will look like this:

The LLM creates a script or an existing text is accepted.
The script is converted into a structured list of scenes in JSON: text, visual type, search queries, importance, and intro tag.
ElevenLabs generates audio with the selected voice.
Separate modules perform searches in Pexels, Pixabay, Wikimedia Commons, and other sources.
The results are brought to a unified format with mandatory preservation of the source, author, and license.
The frame or preview is checked by a multimodal LLM. The number of attempts is limited to three according to the technical task.
If the video does not fit, the program moves to a more precise search for a photograph and applies motion through scaling and panning.
Editing is primarily done through FFmpeg, as it is more stable and faster than MoviePy for long Full HD videos.
At the end, temporary files are cleared, and the user receives a ready MP4, subtitles, and a log of used sources.

The intro will be formed as a separate stage: the program will select scenes with the highest importance rating, filter those for which quality video clips have been found, create introductory text, and edit a teaser before the main part.

Database

It is advisable to use a local SQLite. A separate server for one user is not needed.

The database will store:

already used videos and photos;
identifiers and hashes of materials to avoid duplicates;
source, author, and license;
history of created projects;
status of unfinished tasks;
cache settings;
technical errors and retries. Expand

Budget: 27000 UAH Deadline: 14 days

Hello! I create such pipelines for video assembly. I can send examples of my work in private messages.

The bottleneck here is the rendering speed: moviepy noticeably slows down with the Ken Burns effect, so I use the native zoompan in ffmpeg for zooming with panorama, which allows even a video made from dozens of photos to be assembled quickly. I strictly keep the frame check to 3 steps, just like you: I take the first found one, check with LLM "is it relevant?", if it doesn't fit, I switch to a photo based on an exact query with enhanced motion, which is a sure bet in terms of meaning and saves the LLM budget.

I create sources as separate modules with fallback: if not found in Pexels, we go to Pixabay, then archival Wikimedia, Archive.org, LoC, Europeana, NASA, Smithsonian. Only public domain and free licenses, without parsing YouTube and images from Google. I assemble a 60-second intro teaser from scenes with the highest importance rating based on a separate text intrigue from LLM.

Regarding the database: a heavy database is not needed here; local files plus a lightweight SQLite just for the registry of already used clips are sufficient to avoid repeating videos. The GUI is on PyQt, launched with a double click, all settings (theme, voice from ElevenLabs, options, overlays, folders, cache limit) are in the window, no need to touch the code. I clean up intermediate files after assembly, with a cache limit that removes old ones.

Regarding similar works: I have a ready-made video auto-assembly pipeline (Whisper, clip selection, ffmpeg, Ken Burns, TTS), I will show it in our correspondence.

The cost is 27,000 UAH, the deadline is 2 weeks. I look forward to collaborating. Expand

Budget: 27000 UAH Deadline: 30 days

Good day.
I am ready to create a local Windows program in Python: topic → script → voiceover → selection of video/photos → MP4 (faceless), just for you, without a website.
Portfolio: https://gooru-lab.github.io/portfolio/
Similar experience
• Python, LLM API (OpenAI), pipelines with API keys in the config.
• Automation with files, logs, modular structure.
• Media assembly through ffmpeg / moviepy (voiceover + clips/photos, timing, export MP4).
• Integrations with external APIs (keys in settings, error handling, fallback).
GUI proposal
• PyQt / customtkinter — one window: topic / script insertion, voice (list from ElevenLabs), options (only photos, no voiceover, overlay, subtitles, etc.), progress and logs.
• Settings (keys, folders, cache limit, length, video fate) — in the "Settings" tab, without code editing.
• Separately: post-processing of the finished MP4 (overlay + transparency).
Database
• Sufficient local files: SQLite only for "already used clips/photos" (uniqueness) and a light log — or JSON/SQLite at your choice; cache and finished videos — folders from settings.
• Intermediate files after assembly are deleted; cache limit + "clear" button.
What I include according to the specifications
• LLM script + breakdown into scenes (type, request, highlight 1–10);
• ElevenLabs; selection from ≥6 free sources (modules + fallback);
• Frame check LLM, max. 3 steps; photos with Ken Burns;
• Intro teaser ~60 sec; alternating video/photos; assembly 1920×1080;
• Options from the specifications; README; open code + launch from GUI.
Timeline and cost
• MVP (topic → script → voiceover → Pexels/Pixabay + 2–3 archives → assembly MP4 + basic GUI): 10–14 days, 25–30 thousand UAH
• Full version according to specifications (all sources, intro rules, overlays, subtitles, uniqueness, cache, post-processing overlay): an additional +7–10 days, total 40–50 thousand UAH / ~2.5–3.5 weeks
You will arrange the API keys; video references — for style adjustment. Expand

Budget: 27000 UAH Deadline: 14 days

Hello!

I have carefully reviewed the technical specifications - the task is clear. I have experience with Python, LLM API (OpenAI/Claude), ElevenLabs API, integration of stock services (Pexels, Pixabay), and ffmpeg/moviepy.

What I will implement:
GUI on PyQt - all settings through a window, without editing code
Script generation through LLM + breakdown into scenes
Voiceover through ElevenLabs with voice selection
8+ sources of video/photos with fallback
Frame checking through LLM (max. 3 steps per scene)
Ken Burns effect + particle overlay + intro-tizer
BD of used frames (SQLite) + cache management

Clean commented code, README, all rights will be transferred to you.

Ready for discussion. Expand

Budget: 27000 UAH Deadline: 14 days

Good day, I am a Python developer with extensive experience in AI, as well as in desktop application development and video creation, etc. I can complete your project with high quality. I will write clean, structured, and maintainable application code. Feel free to write - we can discuss the details. I am ready to start working today.

Budget: 26000 UAH Deadline: 12 days

Hello, Sergey! I have thoroughly studied your technical assignment. The presence of such a well-developed UX flow and descriptions of boundary conditions (cache clearing, limits on LLM verification steps) is rare in freelancing. I am ready to develop this faceless video automation pipeline for you using pure Python 3.12.

I will respond strictly to your mandatory points at the end of the technical assignment:

1. Examples of similar work:
There is no direct link to a finished commercial video generator in my portfolio — such automations are created for closed internal needs of clients. From related experience: I constantly work with complex data pipelines, asynchronous requests (httpx/asyncio), and LLM API integration (OpenAI/Anthropic). Implementing a modular plugin system for each of your 10 sources (Pexels, Pixabay, Wikimedia, Archive.org, etc.) will not be difficult.
2. Proposal for GUI:
I suggest using the built-in Tkinter library (with the ttk extension). The advantages for local software for a single user are obvious: zero weight, no heavy external dependencies (unlike PyQt), the script will run with a double click on any Windows. We will make the interface concise: a field for entering the topic/script, a dropdown list of voices, checkboxes for options (modes "Photo only," "No voiceover," "Atmospheric overlay"), a transparency slider, a real-time assembly progress log, and a cache control block.
3. Does the solution use a database:
A local SQLite database is critically necessary here (one .db file next to the script, without server installation). There are two reasons for this: first, maintaining a hash table of used media files to ensure 100% uniqueness (excluding duplicates). Second, proper cache management — the database will store an index of files, size, and the date of the last access to them. Without this, smart clearing by gigabyte limit (LRU cache) will turn into a lottery, and the script may accidentally delete a piece of the clip that is currently being rendered.
4. Cost and deadlines:
I am ready to implement the project in 12 days. The cost is 23,500 UAH. I will provide you with completely clean, open code, requirements.txt, .env.example for your API keys, and a detailed README. All rights to the code will transfer to you.

The main technical risk that I will consider during development is the desynchronization of audio and video during cuts:
The length of the scene should be dictated by the audio. We will first send the text to the ElevenLabs API and definitely use the endpoint with-timestamps. After obtaining the exact duration of the audio track and character-by-character timings, the script will trim the video and calculate the Ken Burns effect. Expand

Budget: 27000 UAH Deadline: 15 days

Good day!
I am developing in Python!
I have good experience working with similar tasks - I will show examples of similar work in private.
I am ready to complete your task.

Budget: 27000 UAH Deadline: 1 day

Hello! I have experience with Python, ffmpeg/moviepy, integrating LLM and ElevenLabs API for automatic video assembly. I would be happy to help you!

Budget: 27000 UAH Deadline: 21 days

Hello, Sergey.

I don't have a public case specifically on video assembly, so I won't present irrelevant work as an analogy. The architecture task is clear: a separate timeline for scenes, interchangeable LLM/source modules, ElevenLabs, ffmpeg, and a local database of used materials.

I suggest using PySide6 for the interface and SQLite for the history of clips, cache, and recovery of unfinished assemblies. The "no voiceover" mode will be immediately separated into a separate timing calculation based on the text, so it won't be a crutch on top of the audio script. First, I will build a control pipeline with 2-3 sources, then expand to the full list and add GUI, overlays, subtitles, and packaging for Windows.

Could you please clarify what the typical duration of the finished video is needed for the acceptance test?

Budget: 27000 UAH Deadline: 10 days

Hello. I have worked on a similar project. A database of photos and videos is needed. For GUI, Tkinter/PyQt is a good choice. It may be possible without a database, but I recommend PostgreSQL.

Budget: 27000 UAH Deadline: 21 days

Hello, Sergey! Your task is a clear pipeline: LLM script → breakdown into scenes (JSON: text, visual type, search query, highlight) → ElevenLabs TTS → selection from Pexels/Pixabay/Wikimedia/Archive.org, etc. with fallback → LLM frame check (maximum 3 steps per scene) → assembly ffmpeg/moviepy: Ken Burns for photos, intro teaser 60 sec from highlight scenes, alternating video/photos, overlays with adjustable transparency, cleanup of temporary files and cache limit.

Answers to your questions from the technical specification:
1. GUI: PyQt — a window with a subject field, a list of voices (pulled via ElevenLabs API), checkboxes for options, an overlay slider, a progress bar, and a clear log. Launch with a double click, all settings in the interface.
2. Database: no server needed. For the database of used clips and cache — local SQLite (one file, no installation required). Keys and settings — in the config file.
3. Work examples: the profile here is new, there is currently no public portfolio, so instead of promises, I offer a trial — in 3 days I will create a mini-prototype for free (topic → script → selection from Pexels/Pixabay → ready MP4 with Ken Burns). Check the result and decide whether to continue.

Deadline for the full version according to the technical specification: 21 days, delivery in stages (prototype → full pipeline → GUI and options → acceptance according to your checklist). For transparency: I write code in conjunction with AI tools, checking and testing manually — for such a pipeline, this is a significant speed advantage. The code is clean, modular, with README and comments; all rights belong to you.

Budget: 27000 UAH Deadline: 5 days

Good day! I will complete it turnkey. I have experience in implementing such projects. I guarantee the completed work. The exact cost will be calculated after discussing all the details. Shall we discuss?

Budget: 27000 UAH Deadline: 14 days

Sergey, to automate the creation of such videos, we need to connect a pipeline of LLM for the script, ElevenLabs for the voice, and the Pexels API for media content. This will solve the problem of manual editing and footage selection, turning a text topic into a ready MP4 on your PC.

I will implement this as a console application with a simple graphical interface using Tkinter or PySide, where you will set the topic, and the program will sequentially call the APIs, download media, and stitch them together using MoviePy. In the end, you will receive a ready file that you will only need to upload.

What duration of videos do you plan to create most often, and how critical is the presence of subtitles in the finished video?

Budget: 27000 UAH Deadline: 20 days

Hello.
I deeply understand the complexity of the task of creating a standalone program for generating faceless videos and propose to develop a high-performance modular system in Python that will ensure reliable integration of LLM, ElevenLabs, and various media sources for dynamic visual sequence formation, taking into account all specified rules and resource optimization.
Particular attention will be paid to the implementation of LLM frame verification, the creation of intro teasers, the Ken Burns effect, cinematic overlays with post-processing capabilities, and effective disk space management, as well as the development of an intuitive GUI on PySide6 for full control without programming.
My significant experience with FFmpeg, multimedia APIs, LLM integrations, and the development of similar tools allows me to leverage existing solutions, which will significantly speed up the process and ensure the creation of clean, scalable, and well-documented code.
I suggest discussing all implementation details, final budget, and timelines in private messages.

Budget: 27000 UAH Deadline: 21 days

Hello! I am ready to develop a program for automatic video assembly using Python. I have experience working with APIs, ffmpeg, and GUI. The completion time is 14 days. I can provide examples of my work upon request.