DEV Community: Machine4321

How to Automate Stock Video Sourcing for TikTok & Shorts Using Python

Machine4321 — Sun, 28 Jun 2026 19:24:59 +0000

How to Automate Stock Video Sourcing for TikTok & Shorts Using Python

Faceless channels on TikTok, YouTube Shorts, and Instagram Reels are booming. Many creators are automating their entire workflow—using AI to write scripts, generate voiceovers, and edit videos.

But one major bottleneck remains: sourcing high-quality background stock videos.

Manually browsing site after site, searching for relevant clips, downloading them, and organizing them into folders is incredibly tedious.

In this tutorial, we will show you how to automate this process completely. You will learn how to write a Python script that bulk-downloads vertical (portrait) stock videos from Pexels based on any search keyword, ready to be fed into your video editing pipeline.

🛠️ The Solution: Apify Pexels Scraper

Instead of struggling with the rate limits of the native Pexels API or parsing heavy HTML pages yourself, we will use the Pexels Video & Image Bulk Scraper on Apify.

This Actor allows us to:

Search for any keyword (e.g. "lofi", "meditation", "gym").
Filter results specifically by Orientation (e.g., portrait for vertical social formats).
Filter by Size (e.g., HD/4K) and Locale (language).
Download raw MP4 files directly to our local machine.

📥 Setup Instructions

1. Install the Apify Client SDK

First, install the official Apify Client package via pip:

pip install apify-client

2. Get Your API Token

Sign up for a free account at apify.com and copy your API Token from your Integrations tab in the console. Set it in your terminal environment:

macOS/Linux: export APIFY_TOKEN="your_token_here"
Windows (PowerShell): $env:APIFY_TOKEN="your_token_here"

🚀 The Python Implementation

Create a file named download_stock_videos.py and paste the following code:

import os
import requests
from apify_client import ApifyClient

def download_file(url, file_path):
    """Helper to download and save raw video file locally."""
    print(f"Downloading: {url}")
    response = requests.get(url, stream=True)
    if response.status_code == 200:
        with open(file_path, 'wb') as f:
            for chunk in response.iter_content(chunk_size=1024*1024):
                if chunk:
                    f.write(chunk)
        print(f"✅ Saved to: {file_path}")
    else:
        print(f"❌ Failed to download {url}")

def main():
    token = os.getenv("APIFY_TOKEN")
    if not token:
        print("Please set your APIFY_TOKEN environment variable.")
        return

    client = ApifyClient(token)

    # Scraper Input Configuration
    run_input = {
        "query": "minimalist aesthetic", # Search keyword
        "mediaType": "videos",           # We only want video clips
        "orientation": "portrait",       # Filter vertical videos for TikTok/Shorts
        "size": "large",                 # HD / 4K resolution
        "maxResults": 5                  # Number of clips to download
    }

    print(f"Starting Pexels Scraper on Apify for query: '{run_input['query']}'...")
    # Run the Actor and wait for completion
    run = client.actor("knobby_wallpaper/pexels-scraper").call(run_input=run_input)

    # Retrieve dataset items
    dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
    print(f"Found {len(dataset_items)} vertical video structures.")

    # Create folder to save videos
    output_dir = "stock_videos"
    os.makedirs(output_dir, exist_ok=True)

    # Download raw MP4 videos locally
    for idx, item in enumerate(dataset_items):
        video_url = item.get("rawUrl") or item.get("videoUrl")
        if not video_url:
            continue

        file_name = f"video_{idx+1}_{item.get('id')}.mp4"
        file_path = os.path.join(output_dir, file_name)

        # Download the file
        download_file(video_url, file_path)

if __name__ == "__main__":
    main()

📈 Going No-Code?

If you prefer to download vertical stock videos directly in your web browser without writing Python scripts, you can run the scraper via the web UI:

👉 Run Pexels Scraper on Apify Store

Simply enter your search keyword, select Portrait (Vertical) as the orientation, click Start, and download your vertical background clips immediately!

Do you automate video generation? What's your setup? Let me know in the comments!

How I Automated Internal Linking for My B2B SaaS Review Blog Using Python

Machine4321 — Sun, 28 Jun 2026 18:40:24 +0000

Internal linking is one of the most overlooked ranking factors in SEO.

For high-ticket affiliate sites—especially in competitive niches like B2B SaaS reviews—structuring your links correctly is the difference between ranking on page 1 of Google or page 10. You want your informational posts linking back to your "Hub" pages (like your "Best CRM Tools" or "Best Accounting Software" reviews) to pass on page authority (Link Juice).

But doing this manually across hundreds of posts is incredibly tedious.

To solve this, I built a Python engine that runs automatically, categorizes my articles, matches key search terms, and safely injects internal HTML links into my WordPress/Astro content database without breaking layouts.

Here is exactly how I built it and how you can implement it.

The Architecture: How the Internal Linker Works

Our Python script performs three main tasks:

Fetch Articles: Download all published and scheduled posts via the WordPress/Astro REST API.
Build Keyword-to-Link Map: Scan post titles, tag them into niches (CRM, Finance, VPN, Web Builders), and generate a sorted dictionary of keywords to link.
Regex Search & Inject: Safely parse raw article HTML, find matching keywords, and wrap them in anchor tags.

🛠️ The Python Implementation

Here is a simplified, functional version of the automated internal linking script.

1. The Mapping Engine

First, we define which keywords should trigger links to specific articles based on their niche. For example, if we have a guide on sales tracking, we want the keyword "CRM" in any other article to link back to our CRM guide.

import re

def build_keyword_map(posts):
    link_targets = {}
    for p in posts:
        title = p['title'].lower()
        url = p['link']
        keywords = []
        is_hub = False

        # Identify Hub articles (e.g. review guides)
        if any(kw in title for kw in ["paras", "arvostelu", "vertailu", "opas"]):
            is_hub = True

        # Niche 1: CRM & Sales Tools
        if any(kw in title for kw in ["crm", "myynnin", "asiakkuus"]):
            keywords.extend(["crm-järjestelmä", "asiakkuudenhallinta", "crm-työkalu"])

        # Niche 2: Finance & Accounting Tools
        if any(kw in title for kw in ["laskutus", "kirjanpito", "laina"]):
            keywords.extend(["laskutusohjelma", "kirjanpito", "yrityslaina"])

        if keywords:
            link_targets[p['id']] = {
                "url": url,
                "is_hub": is_hub,
                # Sort keywords by length descending so long-tail phrases are matched first
                "keywords": sorted(list(set(keywords)), key=len, reverse=True)
            }
    return link_targets

2. The Link Injection Logic

When parsing text, we must make sure we never inject links inside:

Existing anchor (<a>) tags (to avoid nested links).
Image (<img>) source or alt tags.
Heading (<h1>, <h2>, etc.) elements where it might look spammy.

We use regex to search for the keyword outside of HTML tags and replace it:

def inject_link(html_content, keyword, url):
    # Regex to match keyword only outside of HTML tags and existing anchors
    pattern = re.compile(
        rf'(?<!href=")(?<!src=")(?<!>)\b({re.escape(keyword)})\b(?![^<]*</a>)(?![^<]*>)', 
        re.IGNORECASE
    )

    # Inject link only for the first occurrence to avoid link stuffing
    new_html, count = pattern.subn(f'<a href="{url}">{keyword}</a>', html_content, count=1)
    return new_html, count

📈 Real-World Results

I run this script daily as part of my automated publishing robot. It powers my Finnish B2B software comparison site Softa-analyysi.

Since implementing the auto-linker:

Indexation Time: New reviews are discovered and indexed by Google search crawlers in hours instead of days because they are instantly linked from related historical posts.
Domain Authority Boost: Link equity is distributed perfectly to money-generating Hub reviews.
Zero Overhead: The script runs in a lightweight container alongside my data crawlers (like my Trustpilot Reviews Scraper, which I use to gather customer feedback for competitor SaaS analysis).

Automating the small tasks like internal linking and review monitoring allows you to scale content websites to thousands of pages with almost zero maintenance.

How do you handle internal linking in your stack? Let me know in the comments!

How to Scrape Trustpilot Reviews in Python (No Headless Browsers, No Proxy Fees)

Machine4321 — Sun, 28 Jun 2026 18:35:48 +0000

If you've ever tried to scrape customer reviews from Trustpilot to perform sentiment analysis or track competitor ratings, you probably hit a wall pretty quickly.

Modern review platforms are protected by firewalls (like Cloudflare) that block standard scraping scripts. The default solution for most developers is to use headless browsers like Playwright, Puppeteer, or Selenium combined with rotating residential proxies.

But there is a major problem with this approach:

Headless browsers are resource hogs: They consume massive amounts of RAM and CPU.
Proxies are expensive: Paying for gigabytes of residential proxy bandwidth to bypass Cloudflare eats into your budget.

In this tutorial, we will show you how to scrape Trustpilot reviews 100x faster without spinning up a headless browser and without paying for expensive proxies.

The Secret: Parsing `__NEXT_DATA__`

Trustpilot is built on Next.js. This means that when you request a company's review page, the server pre-renders the page and embeds the initial database query output into a special <script> tag in the HTML source code:

<script id="__NEXT_DATA__" type="application/json">
  {
    "props": {
      "pageProps": {
        "reviews": [ ... ]
      }
    }
  }
</script>

Instead of running a heavy browser to render the page and click elements, we can fetch the HTML using a standard HTTP request, extract this single <script> tag, and parse it as a JSON object. This gives us 20 full reviews per page instantly in a fraction of a second!

🛠️ Step-by-Step Python Implementation

We can run this logic on the cloud using a pre-configured serverless Actor. This handles IP rotation and scheduling automatically for free.

1. Install the Apify Client SDK

Open your terminal and install the client package:

pip install apify-client

2. Set Up Your API Token

Sign up for a free account on Apify and get your personal API Token from your Integrations tab. Set it in your terminal environment:

macOS/Linux: export APIFY_TOKEN="your_token_here"
Windows: $env:APIFY_TOKEN="your_token_here"

3. Run the Scraper Script

Save the following code as export_reviews.py and run it:

import os
from apify_client import ApifyClient

def main():
    token = os.getenv("APIFY_TOKEN")
    if not token:
        print("Please set your APIFY_TOKEN environment variable.")
        return

    client = ApifyClient(token)

    # Scrape settings
    run_input = {
        "domain": "apify.com",  # Target domain name
        "maxPages": 3,           # Fetch 3 pages (60 reviews)
        "minRating": 1           # Get all ratings (1-5 stars)
    }

    print("Running Trustpilot Scraper...")
    run = client.actor("knobby_wallpaper/trustpilot-reviews-scraper").call(run_input=run_input)

    # Fetch reviews from the dataset
    dataset_items = client.dataset(run["defaultDatasetId"]).list_items().items
    print(f"\nExtracted {len(dataset_items)} reviews:")
    for item in dataset_items[:5]:
        print(f"- [{item['rating']}/5 Stars] {item['authorName']}: {item['title']}")

    # Download link
    csv_url = f"https://api.apify.com/v2/datasets/{run['defaultDatasetId']}/items?format=csv"
    print(f"\n📥 Download CSV dataset directly: {csv_url}")

if __name__ == "__main__":
    main()

📈 Going No-Code?

If you prefer to download Trustpilot reviews without writing any Python code, you can use the web interface of the scraper directly in your browser:

👉 Run Trustpilot Reviews Scraper on the Apify Store

Simply enter the domain of the company you want to scrape, click Start, and download your dataset as a CSV, Excel, or JSON file in seconds!

For the complete source code of this integration, check out the GitHub Repository.

DEV Community: Machine4321

How to Automate Stock Video Sourcing for TikTok & Shorts Using Python

🛠️ The Solution: Apify Pexels Scraper

📥 Setup Instructions

1. Install the Apify Client SDK

2. Get Your API Token

🚀 The Python Implementation

📈 Going No-Code?

How I Automated Internal Linking for My B2B SaaS Review Blog Using Python

The Architecture: How the Internal Linker Works

🛠️ The Python Implementation

1. The Mapping Engine

2. The Link Injection Logic

📈 Real-World Results

How to Scrape Trustpilot Reviews in Python (No Headless Browsers, No Proxy Fees)

The Secret: Parsing __NEXT_DATA__

🛠️ Step-by-Step Python Implementation

1. Install the Apify Client SDK

2. Set Up Your API Token

3. Run the Scraper Script

📈 Going No-Code?

The Secret: Parsing `__NEXT_DATA__`